Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Types

enum  inventory_item_menu_positon { RIGHT_TERMINAL_EDGE , LEFT_OF_INFO , RIGHT_OF_INFO , LEFT_TERMINAL_EDGE }
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around ()
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
int inventory_item_menu (item_location locThisItem, const std::function< int()> &startx=[]() { return 0;}, const std::function< int()> &width=[]() { return 50;}, inventory_item_menu_positon position=RIGHT_OF_INFO)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void open_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
void reload (item_location &loc, bool prompt=false, bool empty=true)
 
void reload_item ()
 
void reload_wielded (bool prompt=false)
 
void reload_weapon (bool try_everything=true)
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
bool unload (item_location loc)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void wield ()
 
void wield (item_location &loc)
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ inventory_item_menu_positon

Enumerator
RIGHT_TERMINAL_EDGE 
LEFT_OF_INFO 
RIGHT_OF_INFO 
LEFT_TERMINAL_EDGE 

Definition at line 611 of file game.h.

611 {
616 };
@ LEFT_OF_INFO
Definition: game.h:613
@ RIGHT_OF_INFO
Definition: game.h:614
@ RIGHT_TERMINAL_EDGE
Definition: game.h:612
@ LEFT_TERMINAL_EDGE
Definition: game.h:615

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 805 of file game.h.

805 : int {
806 CHANGE_TAB,
807 QUIT,
808 FIRE, // Who knew, apparently you can do that in list_monsters
809 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 284 of file game.cpp.

284 :
286 scent_ptr( *this ),
289 m( *map_ptr ),
290 u( *u_ptr ),
291 scent( *scent_ptr ),
293 uquit( QUIT_NO ),
294 new_game( false ),
296 mostseen( 0 ),
299 next_npc_id( 1 ),
300 next_mission_id( 1 ),
304 seed( 0 ),
305 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
306{
314 world_generator = std::make_unique<worldfactory>();
315 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
316 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
317}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1071
pimpl< spell_events > spell_events_ptr
Definition: game.h:1006
safe_mode_type safe_mode
Definition: game.h:1068
bool safe_mode_warning_logged
Definition: game.h:1082
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:1000
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1116
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:1026
event_bus & events()
Definition: game.cpp:3089
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:1002
character_id next_npc_id
Definition: game.h:1084
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:1004
void reset_light_level()
Definition: game.cpp:3933
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:1005
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1073
pimpl< map > map_ptr
Definition: game.h:995
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1099
pimpl< live_view > liveview_ptr
Definition: game.h:997
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:1003
pimpl< scent_map > scent_ptr
Definition: game.h:999
timed_event_manager & timed_events
Definition: game.h:1014
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1111
int next_mission_id
Definition: game.h:1086
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1028
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:1007
map & m
Definition: game.h:1011
avatar & u
Definition: game.h:1012
scent_map & scent
Definition: game.h:1013
int user_action_counter
Definition: game.h:1105
live_view & liveview
Definition: game.h:998
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1108
pimpl< avatar > u_ptr
Definition: game.h:996
time_point remoteveh_cache_time
Definition: game.h:1092
static void achievement_attained(const achievement *a)
Definition: game.cpp:277
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 12356 of file game.cpp.

12357{
12358 //If player is sleeping, get a dream from a carried artifact
12359 //Don't need to check that player is sleeping here, that's done before calling
12360 std::list<item *> art_items = g->u.get_artifact_items();
12361 std::vector<item *> valid_arts;
12362 std::vector<std::vector<std::string>>
12363 valid_dreams; // Tracking separately so we only need to check its req once
12364 //Pull the list of dreams
12365 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
12366 for( auto &it : art_items ) {
12367 //Pick only the ones with an applicable dream
12368 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
12369 if( art && art->charge_req != ACR_NULL &&
12370 ( it->ammo_remaining() < it->ammo_capacity() ||
12371 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
12372 add_msg( m_debug, "Checking artifact %s", it->tname() );
12373 if( check_art_charge_req( *it ) ) {
12374 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12375 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
12376 add_msg( m_debug, "Adding met dream from %s", it->tname() );
12377 valid_arts.push_back( it );
12378 valid_dreams.push_back( art->dream_msg_met );
12379 }
12380 } else {
12381 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12382 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
12383 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
12384 valid_arts.push_back( it );
12385 valid_dreams.push_back( art->dream_msg_unmet );
12386 }
12387 }
12388 }
12389 }
12390 if( !valid_dreams.empty() ) {
12391 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
12392 const int selected = rng( 0, valid_arts.size() - 1 );
12393 auto it = valid_arts[selected];
12394 auto msg = random_entry( valid_dreams[selected] );
12395 const std::string &dream = string_format( _( msg ), it->tname() );
12396 add_msg( dream );
12397 } else {
12398 add_msg( m_debug, "Didn't have any dreams, sorry" );
12399 }
12400}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:264
std::unique_ptr< game > g
Definition: game.cpp:267
bool check_art_charge_req(item &it)
Definition: game.cpp:12059
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
Definition: mutation.h:39
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 12178 of file game.cpp.

12179{
12180 int net_str = 0;
12181 int net_dex = 0;
12182 int net_per = 0;
12183 int net_int = 0;
12184 int net_speed = 0;
12185
12186 for( auto &i : effects ) {
12187 switch( i ) {
12188 case AEP_STR_UP:
12189 net_str += 4;
12190 break;
12191 case AEP_DEX_UP:
12192 net_dex += 4;
12193 break;
12194 case AEP_PER_UP:
12195 net_per += 4;
12196 break;
12197 case AEP_INT_UP:
12198 net_int += 4;
12199 break;
12200 case AEP_ALL_UP:
12201 net_str += 2;
12202 net_dex += 2;
12203 net_per += 2;
12204 net_int += 2;
12205 break;
12206 case AEP_STR_DOWN:
12207 net_str -= 3;
12208 break;
12209 case AEP_DEX_DOWN:
12210 net_dex -= 3;
12211 break;
12212 case AEP_PER_DOWN:
12213 net_per -= 3;
12214 break;
12215 case AEP_INT_DOWN:
12216 net_int -= 3;
12217 break;
12218 case AEP_ALL_DOWN:
12219 net_str -= 2;
12220 net_dex -= 2;
12221 net_per -= 2;
12222 net_int -= 2;
12223 break;
12224
12225 case AEP_SPEED_UP:
12226 net_speed += 20;
12227 break;
12228 case AEP_SPEED_DOWN:
12229 net_speed -= 20;
12230 break;
12231
12232 case AEP_PBLUE:
12233 break; // No message
12234
12235 case AEP_SNAKES:
12236 add_msg( m_warning, _( "Your skin feels slithery." ) );
12237 break;
12238
12239 case AEP_INVISIBLE:
12240 add_msg( m_good, _( "You fade into invisibility!" ) );
12241 break;
12242
12243 case AEP_CLAIRVOYANCE:
12245 add_msg( m_good, _( "You can see through walls!" ) );
12246 break;
12247
12249 add_msg( m_good, _( "You can see through everything!" ) );
12250 break;
12251
12252 case AEP_STEALTH:
12253 add_msg( m_good, _( "Your steps stop making noise." ) );
12254 break;
12255
12256 case AEP_GLOW:
12257 add_msg( _( "A glow of light forms around you." ) );
12258 break;
12259
12260 case AEP_PSYSHIELD:
12261 add_msg( m_good, _( "Your mental state feels protected." ) );
12262 break;
12263
12265 add_msg( m_good, _( "You feel insulated." ) );
12266 break;
12267
12268 case AEP_CARRY_MORE:
12269 add_msg( m_good, _( "Your back feels strengthened." ) );
12270 break;
12271
12272 case AEP_FUN:
12273 add_msg( m_good, _( "You feel a pleasant tingle." ) );
12274 break;
12275
12276 case AEP_HUNGER:
12277 add_msg( m_warning, _( "You feel hungry." ) );
12278 break;
12279
12280 case AEP_THIRST:
12281 add_msg( m_warning, _( "You feel thirsty." ) );
12282 break;
12283
12284 case AEP_EVIL:
12285 add_msg( m_warning, _( "You feel an evil presence…" ) );
12286 break;
12287
12288 case AEP_SCHIZO:
12289 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
12290 break;
12291
12292 case AEP_RADIOACTIVE:
12293 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
12294 break;
12295
12296 case AEP_MUTAGENIC:
12297 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
12298 break;
12299
12300 case AEP_ATTENTION:
12301 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
12302 break;
12303
12304 case AEP_FORCE_TELEPORT:
12305 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
12306 break;
12307
12308 case AEP_MOVEMENT_NOISE:
12309 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
12310 break;
12311
12312 case AEP_BAD_WEATHER:
12313 add_msg( m_warning, _( "You feel storms coming." ) );
12314 break;
12315
12316 case AEP_SICK:
12317 add_msg( m_bad, _( "You feel unwell." ) );
12318 break;
12319
12320 case AEP_SMOKE:
12321 add_msg( m_warning, _( "A cloud of smoke appears." ) );
12322 break;
12323 default:
12324 //Suppress warnings
12325 break;
12326 }
12327 }
12328
12329 std::string stat_info;
12330 if( net_str != 0 ) {
12331 stat_info += string_format( _( "Str %s%d! " ),
12332 ( net_str > 0 ? "+" : "" ), net_str );
12333 }
12334 if( net_dex != 0 ) {
12335 stat_info += string_format( _( "Dex %s%d! " ),
12336 ( net_dex > 0 ? "+" : "" ), net_dex );
12337 }
12338 if( net_int != 0 ) {
12339 stat_info += string_format( _( "Int %s%d! " ),
12340 ( net_int > 0 ? "+" : "" ), net_int );
12341 }
12342 if( net_per != 0 ) {
12343 stat_info += string_format( _( "Per %s%d! " ),
12344 ( net_per > 0 ? "+" : "" ), net_per );
12345 }
12346
12347 if( !stat_info.empty() ) {
12348 add_msg( m_neutral, stat_info );
12349 }
12350
12351 if( net_speed != 0 ) {
12352 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
12353 }
12354}
@ m_good
Definition: enums.h:253
@ m_neutral
Definition: enums.h:260
@ m_info
Definition: enums.h:258
@ m_bad
Definition: enums.h:254
@ m_warning
Definition: enums.h:257
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3384 of file game.cpp.

3385{
3386 draw_callbacks.erase(
3387 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3388 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3389 return cbw.expired();
3390 } ),
3391 draw_callbacks.end()
3392 );
3393 draw_callbacks.emplace_back( cb );
3394 cb->added = true;
3396}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3349
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1958 of file game.cpp.

1959{
1960 follower_ids.insert( id );
1961 u.follower_ids.insert( id );
1962}
std::set< character_id > follower_ids
Definition: game.h:1087
std::set< character_id > follower_ids
Definition: player.h:710

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12512 of file game.cpp.

12513{
12514 return Creature_range( *this );
12515}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12517 of file game.cpp.

12518{
12519 return monster_range( *this );
12520}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12522 of file game.cpp.

12523{
12524 return npc_range( *this );
12525}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 12426 of file game.cpp.

12427{
12428 return get_npcs_if( [&]( const npc & guy ) {
12429 if( !guy.is_hallucination() ) {
12430 return guy.is_ally( g->u );
12431 } else {
12432 return false;
12433 }
12434 } );
12435}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:12449
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3257

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1946 of file game.cpp.

1947{
1948 int ret = next_mission_id;
1950 return ret;
1951}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3941 of file game.cpp.

3942{
3944 ++next_npc_id;
3945 return ret;
3946}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1751 of file game.cpp.

1752{
1753 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1754 vehicle *&v = veh.v;
1755 if( v->is_following ) {
1756 v->drive_to_local_target( m.getabs( u.pos() ), true );
1757 } else if( v->is_patrolling ) {
1758 v->autopilot_patrol();
1759 }
1760 }
1761}
const tripoint & pos() const override
Definition: character.cpp:709
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8074
VehicleList get_vehicles()
Definition: map.cpp:233
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1963
bool is_patrolling
Definition: vehicle.h:1964
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11845 of file game.cpp.

11846{
11847 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11848 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11849 return;
11850 }
11851 quicksave(); //Driving checks are handled by quicksave()
11852}
time_t last_save_timestamp
Definition: game.h:1089
void quicksave()
Definition: game.cpp:11800

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8569 of file game.cpp.

8570{
8571 static const std::string salvage_string = "salvage";
8572 if( u.controlling_vehicle ) {
8573 add_msg( m_info, _( "You can't butcher while driving!" ) );
8574 return;
8575 }
8576
8577 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8578 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8579 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8580 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8581
8582 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8583 if( m.has_flag( "SEALED", u.pos() ) ) {
8584 if( m.sees_some_items( u.pos(), u ) ) {
8585 add_msg( m_info, _( "You can't access the items here." ) );
8586 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8587 add_msg( m_info, no_corpse_msg );
8588 } else {
8589 add_msg( m_info, no_knife_msg );
8590 }
8591 return;
8592 }
8593
8594 const item *first_item_without_tools = nullptr;
8595 // Indices of relevant items
8596 std::vector<map_stack::iterator> corpses;
8597 std::vector<map_stack::iterator> disassembles;
8598 std::vector<map_stack::iterator> salvageables;
8599 map_stack items = m.i_at( u.pos() );
8600 const inventory &crafting_inv = u.crafting_inventory();
8601
8602 // TODO: Properly handle different material whitelists
8603 // TODO: Improve quality of this section
8604 auto salvage_filter = []( item it ) {
8605 const auto usable = it.get_usable_item( salvage_string );
8606 return usable != nullptr;
8607 };
8608
8609 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8610 int salvage_tool_index = INT_MIN;
8611 item *salvage_tool = nullptr;
8612 const salvage_actor *salvage_iuse = nullptr;
8613 if( !salvage_tools.empty() ) {
8614 salvage_tool = salvage_tools.front();
8615 salvage_tool_index = u.get_item_position( salvage_tool );
8616 item *usable = salvage_tool->get_usable_item( salvage_string );
8617 salvage_iuse = dynamic_cast<const salvage_actor *>(
8618 usable->get_use( salvage_string )->get_actor_ptr() );
8619 }
8620
8621 // Reserve capacity for each to hold entire item set if necessary to prevent
8622 // reallocations later on
8623 corpses.reserve( items.size() );
8624 salvageables.reserve( items.size() );
8625 disassembles.reserve( items.size() );
8626
8627 // Split into corpses, disassemble-able, and salvageable items
8628 // It's not much additional work to just generate a corpse list and
8629 // clear it later, but does make the splitting process nicer.
8630 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8631 if( it->is_corpse() ) {
8632 corpses.push_back( it );
8633 } else {
8634 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8635 salvageables.push_back( it );
8636 }
8637 if( u.can_disassemble( *it, crafting_inv ).success() ) {
8638 disassembles.push_back( it );
8639 } else if( !first_item_without_tools ) {
8640 first_item_without_tools = &*it;
8641 }
8642 }
8643 }
8644
8645 // Clear corpses if butcher and dissect factors are INT_MIN
8646 if( factor == INT_MIN && factorD == INT_MIN ) {
8647 corpses.clear();
8648 }
8649
8650 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8651 if( factor > INT_MIN || factorD > INT_MIN ) {
8652 add_msg( m_info, no_corpse_msg );
8653 } else {
8654 add_msg( m_info, no_knife_msg );
8655 }
8656
8657 if( first_item_without_tools ) {
8658 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8659 // Just for the "You need x to disassemble y" messages
8660 const auto ret = u.can_disassemble( *first_item_without_tools, crafting_inv );
8661 if( !ret.success() ) {
8662 add_msg( m_info, "%s", ret.c_str() );
8663 }
8664 }
8665 return;
8666 }
8667
8668 Creature *hostile_critter = is_hostile_very_close();
8669 if( hostile_critter != nullptr ) {
8670 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8671 hostile_critter->disp_name() ) ) {
8672 return;
8673 }
8674 }
8675
8676 // Magic indices for special butcher options
8677 enum : int {
8678 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8679 MULTIBUTCHER,
8680 MULTIDISASSEMBLE_ONE,
8681 MULTIDISASSEMBLE_ALL,
8682 NUM_BUTCHER_ACTIONS
8683 };
8684 // What are we butchering (i.e.. which vector to pick indices from)
8685 enum {
8686 BUTCHER_CORPSE,
8687 BUTCHER_DISASSEMBLE,
8688 BUTCHER_SALVAGE,
8689 BUTCHER_OTHER // For multisalvage etc.
8690 } butcher_select = BUTCHER_CORPSE;
8691 // Index to std::vector of iterators...
8692 int indexer_index = 0;
8693
8694 // Generate the indexed stacks so we can display them nicely
8695 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8696 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8697 // Always ask before cutting up/disassembly, but not before butchery
8698 size_t ret = 0;
8699 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8700 uilist kmenu;
8701 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8702
8703 size_t i = 0;
8704 // Add corpses, disassembleables, and salvagables to the UI
8705 add_corpses( kmenu, corpses, i );
8706 add_disassemblables( kmenu, disassembly_stacks, i );
8707 if( salvage_iuse && !salvageables.empty() ) {
8708 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8709 }
8710
8711 if( corpses.size() > 1 ) {
8712 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8713 }
8714 if( disassembles.size() > 1 ) {
8715 int time_to_disassemble = 0;
8716 int time_to_disassemble_all = 0;
8717 for( const auto &stack : disassembly_stacks ) {
8718 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8719 time_to_disassemble += time;
8720 time_to_disassemble_all += time * stack.second;
8721 }
8722
8723 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8724 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8725 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8726 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8727 }
8728 if( salvage_iuse && salvageables.size() > 1 ) {
8729 int time_to_salvage = 0;
8730 for( const auto &stack : salvage_stacks ) {
8731 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8732 }
8733
8734 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8735 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8736 }
8737
8738 kmenu.query();
8739
8740 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8741 return;
8742 }
8743
8744 ret = static_cast<size_t>( kmenu.ret );
8745 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8746 butcher_select = BUTCHER_OTHER;
8747 indexer_index = ret;
8748 } else if( ret < corpses.size() ) {
8749 butcher_select = BUTCHER_CORPSE;
8750 indexer_index = ret;
8751 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8752 butcher_select = BUTCHER_DISASSEMBLE;
8753 indexer_index = ret - corpses.size();
8754 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8755 butcher_select = BUTCHER_SALVAGE;
8756 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8757 } else {
8758 debugmsg( "Invalid butchery index: %d", ret );
8759 return;
8760 }
8761 }
8762
8763 if( !u.has_morale_to_craft() ) {
8764 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8765 add_msg( m_info,
8766 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8767 } else {
8768 add_msg( m_info,
8769 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8770 }
8771 return;
8772 }
8773 const auto helpers = u.get_crafting_helpers( 3 );
8774 for( const npc *np : helpers ) {
8775 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8776 }
8777 switch( butcher_select ) {
8778 case BUTCHER_OTHER:
8779 switch( indexer_index ) {
8780 case MULTISALVAGE:
8781 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8782 break;
8783 case MULTIBUTCHER:
8784 butcher_submenu( corpses );
8785 for( map_stack::iterator &it : corpses ) {
8786 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8787 }
8788 break;
8789 case MULTIDISASSEMBLE_ONE:
8790 u.disassemble_all( true );
8791 break;
8792 case MULTIDISASSEMBLE_ALL:
8793 u.disassemble_all( false );
8794 break;
8795 default:
8796 debugmsg( "Invalid butchery type: %d", indexer_index );
8797 return;
8798 }
8799 break;
8800 case BUTCHER_CORPSE: {
8801 butcher_submenu( corpses, indexer_index );
8802 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8803 }
8804 break;
8805 case BUTCHER_DISASSEMBLE: {
8806 // Pick index of first item in the disassembly stack
8807 item *const target = &*disassembly_stacks[indexer_index].first;
8808 u.disassemble( item_location( map_cursor( u.pos() ), target ), true );
8809 }
8810 break;
8811 case BUTCHER_SALVAGE: {
8812 if( !salvage_iuse || !salvage_tool ) {
8813 debugmsg( "null salve_iuse or salvage_tool" );
8814 } else {
8815 // Pick index of first item in the salvage stack
8816 item *const target = &*salvage_stacks[indexer_index].first;
8817 item_location item_loc( map_cursor( u.pos() ), target );
8818 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8819 }
8820 }
8821 break;
8822 }
8823}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:285
player_activity activity
Definition: character.h:1582
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2405
bool has_morale_to_craft() const
Definition: crafting.cpp:330
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:548
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9199
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3955
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:176
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7801
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7775
Definition: map.h:101
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2288
map_stack i_at(const tripoint &p)
Definition: map.cpp:4069
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4715
std::vector< item_location > targets
void disassemble_all(bool one_pass)
Definition: crafting.cpp:2034
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2326
ret_val< bool > can_disassemble(const item &obj, const inventory &inv) const
Check if the player can disassemble an item using the current crafting inventory.
Definition: crafting.cpp:1859
bool disassemble()
Definition: crafting.cpp:1932
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:952
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:932
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8420
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8378
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8399
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8331
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8366
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:828
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:315
string_id< quality > quality_id
Definition: type_id.h:171

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), player::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, player::disassemble(), player::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1332 of file game.cpp.

1333{
1334 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1336 return;
1337 }
1338 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1339 const int light_sight_range = u.sight_range( g_light_level );
1340 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1341
1342 // The maximal offset will leave at least this many tiles
1343 // between the PC and the edge of the main window.
1344 static const int border_range = 2;
1345 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1346 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1347
1348 // velocity at or below this results in no offset at all
1349 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1350 // velocity at or above this results in maximal offset
1351 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1353 float velocity = veh->velocity;
1354 rl_vec2d offset = veh->move_vec();
1355 if( !veh->skidding && veh->player_in_control( u ) &&
1356 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1357 // Use the cruise controlled velocity, but only if
1358 // it is not too different from the actual velocity.
1359 // The actual velocity changes too often (see above slowdown).
1360 // Using it makes would make the offset change far too often.
1361 offset = veh->face_vec();
1362 velocity = veh->cruise_velocity;
1363 }
1364 float rel_offset;
1365 if( std::fabs( velocity ) < min_offset_vel ) {
1366 rel_offset = 0;
1367 } else if( std::fabs( velocity ) > max_offset_vel ) {
1368 rel_offset = ( velocity > 0 ) ? 1 : -1;
1369 } else {
1370 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1371 }
1372 // Squeeze into the corners, by making the offset vector longer,
1373 // the PC is still in view as long as both offset.x and
1374 // offset.y are <= 1
1375 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1376 offset.y /= std::fabs( offset.x );
1377 offset.x = ( offset.x > 0 ) ? +1 : -1;
1378 } else if( std::fabs( offset.y ) > 0.2 ) {
1379 offset.x /= std::fabs( offset.y );
1380 offset.y = offset.y > 0 ? +1 : -1;
1381 }
1382 offset.x *= rel_offset;
1383 offset.y *= rel_offset;
1384 offset.x *= max_offset.x;
1385 offset.y *= max_offset.y;
1386 // [ ----@---- ] sight=6
1387 // [ --@------ ] offset=2
1388 // [ -@------# ] offset=3
1389 // can see sights square in every direction, total visible area is
1390 // (2*sight+1)x(2*sight+1), but the window is only
1391 // getmaxx(w_terrain) x getmaxy(w_terrain)
1392 // The area outside of the window is maxoff (sight-getmax/2).
1393 // If that value is <= 0, the whole visible area fits the window.
1394 // don't apply the view offset at all.
1395 // If the offset is > maxoff, only apply at most maxoff, everything
1396 // above leads to invisible area in front of the car.
1397 // It will display (getmax/2+offset) squares in one direction and
1398 // (getmax/2-offset) in the opposite direction (centered on the PC).
1399 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1400 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1401 if( maxoff.x <= 0 ) {
1402 offset.x = 0;
1403 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1404 offset.x = maxoff.x;
1405 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1406 offset.x = -maxoff.x;
1407 }
1408 if( maxoff.y <= 0 ) {
1409 offset.y = 0;
1410 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1411 offset.y = maxoff.y;
1412 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1413 offset.y = -maxoff.y;
1414 }
1415
1416 // Turn the offset into a vector that increments the offset toward the desired position
1417 // instead of setting it there instantly, should smooth out jerkiness.
1418 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1419
1420 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1421 ( offset_difference.y < 0 ) ? -1 : 1 );
1422 // Shift the current offset in the direction of the calculated offset by one tile
1423 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1424 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1425 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1426 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1427 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1428
1429 set_driving_view_offset( point( offset.x, offset.y ) );
1430}
int posz() const override
Definition: character.h:844
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:714
point driving_view_offset
Definition: game.h:1045
catacurses::window w_terrain
Definition: game.h:1035
void set_driving_view_offset(const point &p)
Definition: game.cpp:1689
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3927
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1979
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1898
int cruise_velocity
Definition: vehicle.h:1900
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1314
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1790 of file game.cpp.

1791{
1793 if( u.has_distant_destination() ) {
1794 if( cancel_auto_move( u, text ) ) {
1795 return true;
1796 } else {
1798 return false;
1799 }
1800 }
1802 return false;
1803 }
1804 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1805 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1807
1808 const auto &action = query_popup()
1809 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1810 .message( force_uc ?
1811 pgettext( "cancel_activity_or_ignore_query",
1812 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1813 pgettext( "cancel_activity_or_ignore_query",
1814 "<color_light_red>%s %s</color>" ),
1815 text, u.activity.get_stop_phrase() )
1816 .option( "YES", allow_key )
1817 .option( "NO", allow_key )
1818 .option( "IGNORE", allow_key )
1819 .query()
1820 .action;
1821
1822 if( action == "YES" ) {
1824 return true;
1825 }
1826 if( action == "IGNORE" ) {
1828 for( auto &activity : u.backlog ) {
1829 activity.ignore_distraction( type );
1830 }
1831 }
1832
1835
1836 return false;
1837}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9242
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1583
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1777
void redraw()
Definition: ui_manager.cpp:285
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1839 of file game.cpp.

1840{
1842 if( u.has_distant_destination() ) {
1843 if( cancel_auto_move( u, text ) ) {
1844 return true;
1845 } else {
1847 return false;
1848 }
1849 }
1850 if( !u.activity ) {
1851 return false;
1852 }
1853 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1857 return true;
1858 }
1859 return false;
1860}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9274

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1763 of file game.cpp.

1765{
1766 //spawn the corpse, rotten by a part of the duration
1768 catch_duration ) ) );
1769 if( u.sees( pos ) ) {
1770 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1771 }
1772 //quietly kill the caught
1773 fish->no_corpse_quiet = true;
1774 fish->die( p );
1775}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:503
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4214
bool no_corpse_quiet
Definition: monster.h:482
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2243
const mtype * type
Definition: monster.h:478
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:4368
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 393 of file npctalk.cpp.

394{
395 int volume = g->u.get_shout_volume();
396
397 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
398 // TODO: Get rid of the z-level check when z-level vision gets "better"
399 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
400 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
401 } );
402 const int available_count = available.size();
403 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
404 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
405 } );
406 const int follower_count = followers.size();
407 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
408 return guy.mission == NPC_MISSION_GUARD_ALLY &&
409 guy.companion_mission_role_id != "FACTION_CAMP" &&
410 guy.can_hear( u.pos(), volume );
411 } );
412 const int guard_count = guards.size();
413
414 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
415 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
416 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
417 return;
418 }
419 std::vector<vehicle *> animal_vehicles;
420 std::vector<vehicle *> following_vehicles;
421 std::vector<vehicle *> magic_vehicles;
422 std::vector<vehicle *> magic_following_vehicles;
423 for( auto &veh : g->m.get_vehicles() ) {
424 auto &v = veh.v;
425 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
426 animal_vehicles.push_back( v );
427 if( v->is_following ) {
428 following_vehicles.push_back( v );
429 }
430 }
431 if( v->magic ) {
432 for( const vpart_reference &vp : v->get_all_parts() ) {
433 const vpart_info &vpi = vp.info();
434 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
435 magic_vehicles.push_back( v );
436 if( v->is_following ) {
437 magic_following_vehicles.push_back( v );
438 }
439 break;
440 }
441 }
442 }
443 }
444
445 uilist nmenu;
446 nmenu.text = std::string( _( "What do you want to do?" ) );
447
448 if( !available.empty() ) {
449 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
450 string_format( _( "Talk to %s" ), available.front()->name ) :
451 _( "Talk to…" )
452 );
453 }
454 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
455 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
456 if( !animal_vehicles.empty() ) {
458 _( "Whistle at your animals pulling vehicles to follow you." ) );
459 }
460 if( !magic_vehicles.empty() ) {
462 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
463 }
464 if( !magic_following_vehicles.empty() ) {
466 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
467 }
468 if( !following_vehicles.empty() ) {
470 _( "Whistle at your animals pulling vehicles to stop following you." ) );
471 }
472 if( !guards.empty() ) {
473 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
474 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
475 _( "Tell someone to follow…" )
476 );
477 }
478 if( !followers.empty() ) {
479 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
480 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
481 _( "Tell someone to guard…" )
482 );
483 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
484 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
485 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
486 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
487 _( "Tell everyone on your team to prepare for danger" ) );
488 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
489 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
490 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
491 }
492 std::string message;
493 std::string yell_msg;
494 bool is_order = true;
495 nmenu.query();
496
497 if( nmenu.ret < 0 ) {
498 return;
499 }
500
501 switch( nmenu.ret ) {
502 case NPC_CHAT_TALK: {
503 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
504 if( npcselect < 0 ) {
505 return;
506 }
507 available[npcselect]->talk_to_u();
508 break;
509 }
510 case NPC_CHAT_YELL:
511 is_order = false;
512 message = _( "loudly." );
513 break;
514 case NPC_CHAT_SENTENCE: {
515 std::string popupdesc = _( "Enter a sentence to yell" );
517 popup.title( _( "Yell a sentence" ) )
518 .width( 64 )
519 .description( popupdesc )
520 .identifier( "sentence" )
521 .max_length( 128 )
522 .query();
523 yell_msg = popup.text();
524 is_order = false;
525 break;
526 }
527 case NPC_CHAT_GUARD: {
528 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
529 if( npcselect < 0 ) {
530 return;
531 }
532 if( npcselect == follower_count ) {
533 for( npc *them : followers ) {
535 }
536 yell_msg = _( "Everyone guard here!" );
537 } else {
538 talk_function::assign_guard( *followers[npcselect] );
539 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
540 }
541 break;
542 }
543 case NPC_CHAT_FOLLOW: {
544 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
545 if( npcselect < 0 ) {
546 return;
547 }
548 if( npcselect == guard_count ) {
549 for( npc *them : guards ) {
551 }
552 yell_msg = _( "Everyone follow me!" );
553 } else {
554 talk_function::stop_guard( *guards[npcselect] );
555 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
556 }
557 break;
558 }
559 case NPC_CHAT_AWAKE:
560 for( npc *them : followers ) {
561 talk_function::wake_up( *them );
562 }
563 yell_msg = _( "Stay awake!" );
564 break;
565 case NPC_CHAT_MOUNT:
566 for( npc *them : followers ) {
567 if( them->has_effect( effect_riding ) ) {
568 continue;
569 }
571 }
572 yell_msg = _( "Mount up!" );
573 break;
575 for( npc *them : followers ) {
576 if( them->has_effect( effect_riding ) ) {
577 them->npc_dismount();
578 }
579 }
580 yell_msg = _( "Dismount!" );
581 break;
582 case NPC_CHAT_DANGER:
583 for( npc *them : followers ) {
584 them->rules.set_danger_overrides();
585 }
586 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
587 "and don't open any doors." );
588 break;
590 for( npc *p : followers ) {
592 }
593 yell_msg = _( "As you were." );
594 break;
595 case NPC_CHAT_ORDERS:
596 npc_temp_orders_menu( followers );
597 break;
600 break;
603 break;
606 break;
609 break;
610 default:
611 return;
612 }
613
614 if( !yell_msg.empty() ) {
615 message = string_format( "\"%s\"", yell_msg );
616 }
617 if( !message.empty() ) {
618 add_msg( _( "You yell %s" ), message );
619 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
620 }
621
622 u.moves -= 100;
623}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:541
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7739
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1984
bool is_following() const
Definition: npc.cpp:2015
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:403
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4108
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:219
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:376
static void tell_veh_stop_following()
Definition: npctalk.cpp:339
static void assign_veh_to_follow()
Definition: npctalk.cpp:350
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:251
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:199
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:213
@ NPC_CHAT_YELL
Definition: npctalk.cpp:194
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:197
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:196
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:210
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:202
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:195
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:209
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:201
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:198
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_TALK
Definition: npctalk.cpp:193
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:212
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:360
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 343 of file game.cpp.

344{
345 auto &tree = world_generator->get_mod_manager().get_tree();
346
347 // deduplicated list of mods to check
348 std::set<mod_id> check( opts.begin(), opts.end() );
349
350 // if no specific mods specified check all non-obsolete mods
351 if( check.empty() ) {
352 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
353 if( !e->obsolete ) {
354 check.emplace( e );
355 }
356 }
357 }
358
359 if( check.empty() ) {
360 world_generator->set_active_world( nullptr );
361 world_generator->init();
362 const std::vector<mod_id> mods_empty;
363 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
364 world_generator->set_active_world( test_world );
365
366 // if no loadable mods then test core data only
367 try {
370 } catch( const std::exception &err ) {
371 std::cerr << "Error loading data from json: " << err.what() << std::endl;
372 }
373
374 std::string world_name = world_generator->active_world->world_name;
375 world_generator->delete_world( world_name, true );
376
379 }
380
381 for( const auto &e : check ) {
382 world_generator->set_active_world( nullptr );
383 world_generator->init();
384 const std::vector<mod_id> mods_empty;
385 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
386 if( !test_world ) {
387 std::cerr << "Failed to generate test world." << std::endl;
388 return false;
389 }
390 world_generator->set_active_world( test_world );
391
392 if( !e.is_valid() ) {
393 std::cerr << "Unknown mod: " << e.str() << std::endl;
394 return false;
395 }
396
397 const MOD_INFORMATION &mod = *e;
398
399 if( !tree.is_available( mod.ident ) ) {
400 std::cerr << "Missing dependencies: " << mod.name() << "\n"
401 << tree.get_node( mod.ident )->s_errors() << std::endl;
402 return false;
403 }
404
405 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
406
407 try {
409
410 // Load any dependencies
411 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
412 load_data_from_dir( dep->path, dep->ident.str(), ui );
413 }
414
415 // Load mod itself
416 load_data_from_dir( mod.path, mod.ident.str(), ui );
418 } catch( const std::exception &err ) {
419 std::cerr << "Error loading data: " << err.what() << std::endl;
420 }
421
422 std::string world_name = world_generator->active_world->world_name;
423 world_generator->delete_world( world_name, true );
424
427 }
428 return true;
429}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:626
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:111
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:445
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:436
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6300 of file game.cpp.

6301{
6302 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6303}
static zone_manager & get_manager()
Definition: clzones.cpp:125
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 9120 of file game.cpp.

9121{
9122 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
9123 // Already warned player since safe_mode_warning_logged is set.
9124 return false;
9125 }
9126
9127 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
9128 if( !msg_ignore.empty() ) {
9129 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
9130 // Operate on a wide-char basis to prevent corrupted multi-byte string
9131 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
9132 msg_ignore = wstr_to_utf8( msg_ignore_wide );
9133 }
9134
9136 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
9137 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
9139 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
9140 } else {
9142 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
9143 }
9145 return false;
9146 }
9147 if( safe_mode != SAFE_MODE_STOP ) {
9148 return true;
9149 }
9150 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
9151 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
9152 return true;
9153 }
9154 // Monsters around and we don't want to run
9155 std::string spotted_creature_name;
9156 const monster_visible_info &mon_visible = u.get_mon_visible();
9157 const auto &new_seen_mon = mon_visible.new_seen_mon;
9158
9159 if( new_seen_mon.empty() ) {
9160 // naming consistent with code in game::mon_info
9161 spotted_creature_name = _( "a survivor" );
9163 } else {
9164 spotted_creature_name = new_seen_mon.back()->name();
9165 get_safemode().lastmon_whitelist = spotted_creature_name;
9166 }
9167
9168 std::string whitelist;
9169 if( !get_safemode().empty() ) {
9170 whitelist = string_format( _( " or %s to whitelist the monster" ),
9172 }
9173
9174 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
9176 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
9177 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
9179 return false;
9180}
std::string press_x(action_id act)
Definition: action.cpp:451
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1176
int get_int_base() const override
Definition: avatar.cpp:1006
monster_visible_info & get_mon_visible()
Definition: avatar.h:210
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:281
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:286
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:40

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6295 of file game.cpp.

6296{
6297 return zone_manager::get_manager().has( type, m.getabs( where ) );
6298}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1028 of file game.cpp.

1029{
1030 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1031 // Put (non-hallucinations) into the overmap so they are not lost.
1032 for( monster &critter : all_monsters() ) {
1033 despawn_monster( critter );
1034 }
1035 // Reset NPC factions and disposition
1037 // Save the factions', missions and set the NPC's overmap coordinates
1038 // Npcs are saved in the overmap.
1039 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1040 // save artifacts.
1042
1043 // and the overmap, and the local map.
1044 save_maps(); //Omap also contains the npcs who need to be saved.
1045 }
1046
1047 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1048 std::vector<std::string> vRip;
1049
1050 int iMaxWidth = 0;
1051 int iNameLine = 0;
1052 int iInfoLine = 0;
1053
1056 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1057 vRip.emplace_back( " _______ ___" );
1058 vRip.emplace_back( " < `/ |" );
1059 vRip.emplace_back( " > _ _ (" );
1060 vRip.emplace_back( " | |_) | |_) |" );
1061 vRip.emplace_back( " | | \\ | | |" );
1062 vRip.emplace_back( " ______.__%_| |_________ __" );
1063 vRip.emplace_back( " _/ \\| |" );
1064 iNameLine = vRip.size();
1065 vRip.emplace_back( "| <" );
1066 vRip.emplace_back( "| |" );
1067 iMaxWidth = utf8_width( vRip.back() );
1068 vRip.emplace_back( "| |" );
1069 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1070 vRip.emplace_back( " | |" );
1071 iInfoLine = vRip.size();
1072 vRip.emplace_back( " | |" );
1073 vRip.emplace_back( " | <" );
1074 vRip.emplace_back( " | |" );
1075 vRip.emplace_back( " | _ |" );
1076 vRip.emplace_back( " |__/ |" );
1077 vRip.emplace_back( " % / `--. |%" );
1078 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1079 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1080 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1081 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1082
1083 } else {
1084 vRip.emplace_back( " _______ ___" );
1085 vRip.emplace_back( " | \\/ |" );
1086 vRip.emplace_back( " | |" );
1087 vRip.emplace_back( " | |" );
1088 iInfoLine = vRip.size();
1089 vRip.emplace_back( " | |" );
1090 vRip.emplace_back( " | |" );
1091 vRip.emplace_back( " | |" );
1092 vRip.emplace_back( " | |" );
1093 vRip.emplace_back( " | <" );
1094 vRip.emplace_back( " | _ |" );
1095 vRip.emplace_back( " |__/ |" );
1096 vRip.emplace_back( " ______.__%_| |__________ _" );
1097 vRip.emplace_back( " _/ \\| \\" );
1098 iNameLine = vRip.size();
1099 vRip.emplace_back( "| <" );
1100 vRip.emplace_back( "| |" );
1101 iMaxWidth = utf8_width( vRip.back() );
1102 vRip.emplace_back( "| |" );
1103 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1104 vRip.emplace_back( " % / `_-. _ |%" );
1105 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1106 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1107 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1108 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1109 }
1110 } else {
1111 vRip.emplace_back( R"( _________ ____ )" );
1112 vRip.emplace_back( R"( _/ `/ \_ )" );
1113 vRip.emplace_back( R"( _/ _ _ \_. )" );
1114 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1115 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1116 vRip.emplace_back( R"( _/ \_ )" );
1117 vRip.emplace_back( R"(| |)" );
1118 iNameLine = vRip.size();
1119 vRip.emplace_back( R"( ) < )" );
1120 vRip.emplace_back( R"(| |)" );
1121 vRip.emplace_back( R"(| |)" );
1122 vRip.emplace_back( R"(| _ |)" );
1123 vRip.emplace_back( R"(|__/ |)" );
1124 iMaxWidth = utf8_width( vRip.back() );
1125 vRip.emplace_back( R"( / `--. |)" );
1126 vRip.emplace_back( R"(| ( )" );
1127 iInfoLine = vRip.size();
1128 vRip.emplace_back( R"(| |)" );
1129 vRip.emplace_back( R"(| |)" );
1130 vRip.emplace_back( R"(| % . |)" );
1131 vRip.emplace_back( R"(| @` %% |)" );
1132 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1133 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1134 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1135 }
1136
1137 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1138 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1139
1141 point( iOffsetX, iOffsetY ) );
1142 draw_border( w_rip );
1143
1144 sfx::do_player_death_hurt( g->u, true );
1149
1150 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1151 size_t iX = 0;
1152 const char *str = vRip[iY].data();
1153 for( int slen = vRip[iY].size(); slen > 0; ) {
1154 const uint32_t cTemp = UTF8_getch( &str, &slen );
1155 if( cTemp != U' ' ) {
1156 nc_color ncColor = c_light_gray;
1157
1158 if( cTemp == U'%' ) {
1159 ncColor = c_green;
1160
1161 } else if( cTemp == U'_' || cTemp == U'|' ) {
1162 ncColor = c_white;
1163
1164 } else if( cTemp == U'@' ) {
1165 ncColor = c_brown;
1166
1167 } else if( cTemp == U'*' ) {
1168 ncColor = c_red;
1169 }
1170
1171 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1172 cTemp );
1173 }
1174 iX += mk_wcwidth( cTemp );
1175 }
1176 }
1177
1178 std::string sTemp;
1179
1180 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1181
1183 const int minutes = to_minutes<int>( survived ) % 60;
1184 const int hours = to_hours<int>( survived ) % 24;
1185 const int days = to_days<int>( survived );
1186
1187 if( days > 0 ) {
1188 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1189 } else if( hours > 0 ) {
1190 sTemp = string_format( "%dh %dm", hours, minutes );
1191 } else {
1192 sTemp = string_format( "%dm", minutes );
1193 }
1194
1195 center_print( w_rip, iInfoLine++, c_white, sTemp );
1196
1197 const int iTotalKills = get_kill_tracker().monster_kill_count();
1198
1199 sTemp = _( "Kills:" );
1200 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1201 ( sTemp + " " ) );
1202 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1203
1204 sTemp = _( "In memory of:" );
1205 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1207 sTemp );
1208
1209 sTemp = u.name;
1210 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1211 sTemp );
1212
1213 sTemp = _( "Last Words:" );
1214 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1216 sTemp );
1217
1218 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1219 std::string sLastWords = string_input_popup()
1220 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1221 .max_length( iMaxWidth - 4 - 1 )
1222 .query_string();
1223 death_screen();
1224 const bool is_suicide = uquit == QUIT_SUICIDE;
1225 events().send<event_type::game_over>( is_suicide, sLastWords );
1226 // Struck the save_player_data here to forestall Weirdness
1227 std::string char_filename = generate_memorial_filename( u.name );
1228 move_save_to_graveyard( char_filename );
1229 write_memorial_file( char_filename, sLastWords );
1230 memorial().clear();
1231 std::vector<std::string> characters = list_active_characters();
1232 // remove current player from the active characters list, as they are dead
1233 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1234 characters.end(), u.name );
1235 if( curchar != characters.end() ) {
1236 characters.erase( curchar );
1237 }
1238
1239 if( characters.empty() ) {
1240 bool queryDelete = false;
1241 bool queryReset = false;
1242
1243 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1244 bool decided = false;
1245 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1246 "will not all reset when starting a new character in an "
1247 "already-played world. This can lead to some strange "
1248 "behavior.\n\n"
1249 "Are you sure you wish to keep this world?"
1250 );
1251
1252 while( !decided ) {
1253 uilist smenu;
1254 smenu.allow_cancel = false;
1255 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1256 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1257 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1258 smenu.query();
1259
1260 switch( smenu.ret ) {
1261 case 0:
1262 queryReset = true;
1263 decided = true;
1264 break;
1265 case 1:
1266 queryDelete = true;
1267 decided = true;
1268 break;
1269 case 2:
1270 decided = query_yn( buffer );
1271 break;
1272 }
1273 }
1274 }
1275
1276 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1277 world_generator->delete_world( world_generator->active_world->world_name, true );
1278
1279 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1280 world_generator->delete_world( world_generator->active_world->world_name, false );
1281 }
1282 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1283 std::string tmpmessage;
1284 for( auto &character : characters ) {
1285 tmpmessage += "\n ";
1286 tmpmessage += character;
1287 }
1288 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1289 }
1290 if( gamemode ) {
1291 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1292 }
1293 }
1294
1295 //Reset any offset due to driving
1297
1298 //clear all sound channels
1304
1305 MAPBUFFER.reset();
1307
1308#if defined(__ANDROID__)
1309 quick_shortcuts_map.clear();
1310#endif
1311 return true;
1312}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1570
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2786
bool save_maps()
Definition: game.cpp:3050
std::unique_ptr< special_game > gamemode
Definition: game.h:1103
void death_screen()
Definition: game.cpp:2736
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12517
bool save_factions_missions_npcs()
Definition: game.cpp:3036
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11542
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:966
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:3149
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:3134
bool save_artifacts()
Definition: game.cpp:3044
memorial_logger & memorial()
Definition: game.cpp:3099
void reset_npc_dispositions()
Definition: game.cpp:3008
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1001
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4375 of file game.cpp.

4376{
4377 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4378 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4379 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4380
4381 bool npc_is_dead = false;
4382 // can't use all_npcs as that does not include dead ones
4383 for( const auto &n : active_npc ) {
4384 if( n->is_dead() ) {
4385 n->die( nullptr ); // make sure this has been called to create corpses etc.
4386 npc_is_dead = true;
4387 }
4388 }
4389
4390 if( monster_is_dead ) {
4391 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4392 critter_tracker->remove_dead();
4393 }
4394
4395 if( npc_is_dead ) {
4396 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4397 if( ( *it )->is_dead() ) {
4398 remove_npc_follower( ( *it )->getID() );
4399 overmap_buffer.remove_npc( ( *it )->getID() );
4400 it = active_npc.erase( it );
4401 } else {
4402 it++;
4403 }
4404 }
4405 }
4406
4407 critter_died = false;
4408}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1964
pimpl< Creature_tracker > critter_tracker
Definition: game.h:1021
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1085
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1097
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 5041 of file game.cpp.

5042{
5043 critter_tracker->clear();
5044}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5455 of file game.cpp.

5456{
5457 static const itype_id fuel_type_animal( "animal" );
5458 int veh_part = -1;
5459 vehicle *veh = remoteveh();
5460 if( veh == nullptr ) {
5461 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5462 veh = &vp->vehicle();
5463 veh_part = vp->part_index();
5464 }
5465 }
5466 if( veh != nullptr && veh->player_in_control( u ) &&
5467 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5468 veh->use_controls( u.pos() );
5469 } else if( veh && veh->player_in_control( u ) &&
5470 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5471 u.controlling_vehicle = false;
5472 add_msg( m_info, _( "You let go of the reins." ) );
5473 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5474 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5475 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5476 u.in_vehicle ) {
5477 if( u.has_trait( trait_WAYFARER ) ) {
5478 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5479 return;
5480 }
5481 if( !veh->interact_vehicle_locked() ) {
5482 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5483 return;
5484 }
5485 if( veh->engine_on ) {
5486 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5487 return;
5488 }
5489 u.controlling_vehicle = true;
5490 add_msg( _( "You take control of the %s." ), veh->name );
5491 } else {
5492 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5493 return;
5494 }
5495 veh->start_engines( true );
5496 }
5497 } else { // Start looking for nearby vehicle controls.
5498 int num_valid_controls = 0;
5499 cata::optional<tripoint> vehicle_position;
5500 cata::optional<vpart_reference> vehicle_controls;
5501 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5502 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5503 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5504 if( controls ) {
5505 num_valid_controls++;
5506 vehicle_position = elem;
5507 vehicle_controls = controls;
5508 }
5509 }
5510 }
5511 if( num_valid_controls < 1 ) {
5512 add_msg( _( "No vehicle controls found." ) );
5513 return;
5514 } else if( num_valid_controls > 1 ) {
5515 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5516 if( !vehicle_position ) {
5517 return;
5518 }
5519 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5520 if( vp ) {
5521 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5522 if( !vehicle_controls ) {
5523 add_msg( _( "The vehicle doesn't have controls there." ) );
5524 return;
5525 }
5526 } else {
5527 add_msg( _( "No vehicle there." ) );
5528 return;
5529 }
5530 }
5531 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5532 if( vehicle_controls ) {
5533 veh = &vehicle_controls->vehicle();
5534 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5535 return;
5536 }
5537 veh->use_controls( *vehicle_position );
5538 //May be folded up (destroyed), so need to re-get it
5539 veh = g->remoteveh();
5540 }
5541 }
5542 if( veh ) {
5543 // If we reached here, we gained control of a vehicle.
5544 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5545 for( const tripoint &target : veh->get_points() ) {
5546 u.clear_memorized_tile( m.getabs( target ) );
5547 }
5548 veh->is_following = false;
5549 veh->is_patrolling = false;
5550 veh->autopilot_on = false;
5551 veh->is_autodriving = false;
5552 }
5553}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1013
bool in_vehicle
Definition: character.h:1577
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:163
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2572
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8422
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1004
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:99
bool engine_on
Definition: vehicle.h:1969
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6581
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4200
std::string name
Definition: vehicle.h:1829
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1977
bool is_autodriving
Definition: vehicle.h:1962
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3286 of file game.cpp.

3287{
3289 if( !ui ) {
3290 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3291 ui->on_redraw( []( const ui_adaptor & ) {
3292 g->draw();
3293 } );
3294 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3295 // remove some space for the sidebar, this is the maximal space
3296 // (using standard font) that the terrain window can have
3297 const int sidebar_left = panel_manager::get_manager().get_width_left();
3298 const int sidebar_right = panel_manager::get_manager().get_width_right();
3299
3301 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3304
3305 /**
3306 * In tiles mode w_terrain can have a different font (with a different
3307 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3308 * might have a different dimension then the normal font used everywhere else.
3309 *
3310 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3311 * be displayed in w_terrain (using it's specific tile dimension), not
3312 * including partially drawn squares at the right/bottom. You should
3313 * use it whenever you want to draw specific squares in that window or to
3314 * determine whether a specific square is draw on screen (or outside the screen
3315 * and needs scrolling).
3316 *
3317 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3318 * w_terrain in the standard font dimension (the font that everything else uses).
3319 * You usually don't have to use it, expect for positioning of windows,
3320 * because the window positions use the standard font dimension.
3321 *
3322 * The code here calculates size available for w_terrain, caps it at
3323 * max_view_size (the maximal view range than any character can have at
3324 * any time).
3325 * It is stored in TERRAIN_WINDOW_*.
3326 */
3328
3329 // Position of the player in the terrain window, it is always in the center
3332
3334 point( sidebar_left, 0 ) );
3335
3336 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3338
3339 // need to init in order to avoid crash. gets updated by the panel code.
3341
3342 ui.position_from_window( catacurses::stdscr );
3343 } );
3344 ui->mark_resize();
3345 }
3346 return ui;
3347}
catacurses::window w_pixel_minimap
Definition: game.h:1039
catacurses::window w_minimap_ptr
Definition: game.h:1076
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1122
catacurses::window w_minimap
Definition: game.h:1038
catacurses::window w_terrain_ptr
Definition: game.h:1075
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2293
int get_width_left()
Definition: panels.cpp:2301
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 971 of file game.cpp.

972{
973 if( !get_option<bool>( "STATIC_NPC" ) ||
974 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
975 return; //Do not generate a starting npc.
976 }
977
978 //We don't want more than one starting npc per starting location
979 const int radius = 1;
980 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
981 return; //There is already an NPC in this starting location
982 }
983
984 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
985 tmp->normalize();
986 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
987 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
989 tmp->form_opinion( u );
990 tmp->set_attitude( NPCATT_NULL );
991 //This sets the NPC mission. This NPC remains in the starting location.
992 tmp->mission = NPC_MISSION_SHELTER;
993 tmp->chatbin.first_topic = "TALK_SHELTER";
994 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
995 tmp->set_fac( faction_id( "no_faction" ) );
996 //One random starting NPC mission
997 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
998 tmp->getID() ) );
999}
int get_levy() const
Definition: game.cpp:12407
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:12402
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4846 of file game.cpp.

4847{
4848 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4849 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4850 return nullptr;
4851 }
4852 // if we wanted to check for an NPC / player / avatar,
4853 // there is sometimes a monster AND an NPC/player there at the same time.
4854 // because the NPC/player etc may be riding that monster.
4855 // so only return the monster if we were actually looking for a monster.
4856 // otherwise, keep looking for the rider.
4857 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4858 // which is ok for the occasions where that happens.
4859 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4860 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4861 std::is_same<T, const Creature>::value ) ) {
4862 return dynamic_cast<T *>( mon_ptr.get() );
4863 }
4864 }
4865 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4866 if( p == u.pos() ) {
4867 return dynamic_cast<T *>( &u );
4868 }
4869 }
4870 for( auto &cur_npc : active_npc ) {
4871 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4872 return dynamic_cast<T *>( cur_npc.get() );
4873 }
4874 }
4875 return nullptr;
4876}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4879 of file game.cpp.

4880{
4881 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4882}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4925 of file game.cpp.

4926{
4927 if( id == u.getID() ) {
4928 // player is always alive, therefore no is-dead check
4929 return dynamic_cast<T *>( &u );
4930 }
4931 return find_npc( id );
4932}
character_id getID() const
Definition: character.cpp:472
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1953

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2736 of file game.cpp.

2737{
2738 gamemode->game_over();
2742 follower_ids.clear();
2744}
stats_tracker & stats()
Definition: game.cpp:3094
void disp_NPC_epilogues()
Definition: game.cpp:3173
void display_faction_epilogues()
Definition: game.cpp:3190
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11542 of file game.cpp.

11543{
11544 if( !critter.is_hallucination() ) {
11545 // hallucinations aren't stored, they come and go as they like,
11547 }
11548
11549 critter.on_unload();
11550 remove_zombie( critter );
11551 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11552 critter.set_hp( 0 );
11553}
void remove_zombie(const monster &critter)
Definition: game.cpp:5036
bool is_hallucination() const override
Definition: monster.cpp:2648
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:2980
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1631
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 9188 of file game.cpp.

9189{
9190 monster *const mon_ptr = critter_at<monster>( p );
9191 if( !mon_ptr ) {
9192 return false;
9193 }
9194 monster &critter = *mon_ptr;
9195 if( critter.friendly == 0 || critter.has_flag( MF_RIDEABLE_MECH ) ||
9196 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
9197 // Can only disable / reprogram friendly monsters
9198 return false;
9199 }
9200 const auto mid = critter.type->id;
9201 const auto mon_item_id = critter.type->revert_to_itype;
9202 if( !mon_item_id.is_empty() &&
9203 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
9204
9205 u.moves -= 100;
9206 m.add_item_or_charges( p, critter.to_item() );
9207 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
9208 for( auto &ammodef : critter.ammo ) {
9209 if( ammodef.second > 0 ) {
9210 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
9211 }
9212 }
9213 }
9214 remove_zombie( critter );
9215 return true;
9216 }
9217 // Manhacks are special, they have their own menu here.
9218 if( mid == mon_manhack ) {
9219 int choice = UILIST_CANCEL;
9220 if( critter.has_effect( effect_docile ) ) {
9221 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
9222 } else {
9223 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
9224 }
9225 switch( choice ) {
9226 case 0:
9227 if( critter.has_effect( effect_docile ) ) {
9228 critter.remove_effect( effect_docile );
9229 if( one_in( 3 ) ) {
9230 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
9231 critter.name() );
9232 }
9233 } else {
9234 critter.add_effect( effect_docile, 1_turns, num_bp );
9235 if( one_in( 3 ) ) {
9236 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
9237 critter.name() );
9238 }
9239 }
9240 u.moves -= 100;
9241 return true;
9242 default:
9243 break;
9244 }
9245 }
9246 return false;
9247}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1133
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4173
bool has_flag(m_flag f) const override
Definition: monster.cpp:869
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2788
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1807
int friendly
Definition: monster.h:471
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:492
std::map< itype_id, int > ammo
Definition: monster.h:512
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:361
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 3173 of file game.cpp.

3174{
3175 // TODO: This search needs to be expanded to all NPCs
3176 for( auto elem : follower_ids ) {
3178 if( !guy ) {
3179 continue;
3180 }
3181 const auto new_win = []() {
3183 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3184 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3185 };
3186 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
3187 }
3188}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 3224 of file game.cpp.

3225{
3226 const tripoint_abs_omt ppos = u.global_omt_location();
3227 const tripoint &lpos = u.pos();
3228 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
3229 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
3230
3232 ui_adaptor ui;
3233 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
3236 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
3237 ui.position_from_window( w );
3238 } );
3239 ui.mark_resize();
3240 ui.on_redraw( [&]( const ui_adaptor & ) {
3241 werase( w );
3242 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3243 // NOLINTNEXTLINE(cata-use-named-point-constants)
3244 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3245 size_t i;
3246 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3247 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3248 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3249 apos.to_string() );
3250 }
3251 for( const monster &m : all_monsters() ) {
3252 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3253 m.posx(), m.posy(), m.posz() );
3254 ++i;
3255 }
3256 wnoutrefresh( w );
3257 } );
3258
3259 input_context ctxt( "DISP_NPCS" );
3260 ctxt.register_action( "CONFIRM" );
3261 ctxt.register_action( "QUIT" );
3262 ctxt.register_action( "HELP_KEYBINDINGS" );
3263 bool stop = false;
3264 while( !stop ) {
3266 const std::string action = ctxt.handle_input();
3267 if( action == "CONFIRM" || action == "QUIT" ) {
3268 stop = true;
3269 }
3270 }
3271}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6347
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1320
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 3190 of file game.cpp.

3191{
3192 for( const auto &elem : faction_manager_ptr->all() ) {
3193 if( elem.second.known_by_u ) {
3194 const std::vector<std::string> epilogue = elem.second.epilogue();
3195 if( !epilogue.empty() ) {
3196 const auto new_win = []() {
3198 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3199 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3200 };
3201 scrollable_text( new_win, elem.second.name,
3202 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
3203 []( const std::string & lhs, const std::string & rhs ) -> std::string {
3204 return lhs + "\n" + rhs;
3205 } ) );
3206 }
3207 }
3208 }
3209}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:1022

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11754 of file game.cpp.

11755{
11756 if( use_tiles ) {
11758 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11759 return;
11760 }
11761 uilist lighting_menu;
11762 std::vector<std::string> lighting_menu_strings{
11763 "Global lighting conditions"
11764 };
11765
11766 int count = 0;
11767 for( const auto &menu_str : lighting_menu_strings ) {
11768 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11769 }
11770
11771 lighting_menu.w_y_setup = 0;
11772 lighting_menu.query();
11773 if( ( lighting_menu.ret >= 0 ) &&
11774 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11775 g->displaying_lighting_condition = lighting_menu.ret;
11776 }
11777 }
11778}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11650
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11645 of file game.cpp.

11646{
11648}
cata::optional< action_id > displaying_overlays
Definition: game.h:967

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11780 of file game.cpp.

11781{
11782 if( use_tiles ) {
11784 }
11785}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11659 of file game.cpp.

11660{
11661 if( use_tiles ) {
11663 } else {
11664 int div;
11665 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11666 if( !got_value || div < 1 ) {
11667 add_msg( _( "Never mind." ) );
11668 return;
11669 }
11670 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11671 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11672 } );
11673 g->add_draw_callback( scent_cb );
11674
11677 }
11678}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:681
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11680 of file game.cpp.

11681{
11682 if( use_tiles ) {
11684 }
11685}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11650 of file game.cpp.

11651{
11652 if( display_overlay_state( action ) ) {
11653 displaying_overlays.reset();
11654 } else {
11656 }
11657}
bool display_overlay_state(action_id)
Definition: game.cpp:11645

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11787 of file game.cpp.

11788{
11789 if( use_tiles ) {
11791 }
11792}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11687 of file game.cpp.

11688{
11689 if( use_tiles ) {
11691 }
11692}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11694 of file game.cpp.

11695{
11696 if( use_tiles ) {
11699 std::vector< tripoint > locations;
11700 uilist creature_menu;
11701 int num_creatures = 0;
11702 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11703 locations.emplace_back( g->u.pos() ); // add player first.
11704 for( const Creature &critter : g->all_creatures() ) {
11705 if( critter.is_player() ) {
11706 continue;
11707 }
11708 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11709 locations.emplace_back( critter.pos() );
11710 }
11711
11712 pointmenu_cb callback( locations );
11713 creature_menu.callback = &callback;
11714 creature_menu.w_y_setup = 0;
11715 creature_menu.query();
11716 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11717 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11719 }
11720 } else {
11722 }
11723 }
11724}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:5026
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1058
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1434 of file game.cpp.

1435{
1436 if( is_game_over() ) {
1437 return cleanup_at_end();
1438 }
1439 // Actual stuff
1440 if( new_game ) {
1441 new_game = false;
1442 } else {
1443 gamemode->per_turn();
1444 calendar::turn += 1_turns;
1445 }
1446
1447 // starting a new turn, clear out temperature cache
1449 weather.clear_temp_cache();
1450
1451 if( npcs_dirty ) {
1452 load_npcs();
1453 }
1454
1457 // If controlling a vehicle that is owned by someone else
1459 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1460 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1461 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1462 }
1463 }
1464 // If riding a horse - chance to spook
1465 if( u.is_mounted() ) {
1467 }
1468 if( calendar::once_every( 1_days ) ) {
1470 }
1471
1472 // Move hordes every 2.5 min
1475 // Hordes that reached the reality bubble need to spawn,
1476 // make them spawn in invisible areas only.
1477 m.spawn_monsters( false );
1478 }
1479
1481
1482 u.update_body();
1483
1484 // Auto-save if autosave is enabled
1485 if( get_option<bool>( "AUTOSAVE" ) &&
1486 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1487 !u.is_dead_state() ) {
1488 autosave();
1489 }
1490
1491 weather.update_weather();
1493
1497 // Process NPC sound events before they move or they hear themselves talking
1498 for( npc &guy : all_npcs() ) {
1499 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1501 }
1502 }
1503
1504 // Process sound events into sound markers for display to the player.
1506
1507 if( u.is_deaf() ) {
1509 }
1510
1511 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1512 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1513 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1514 cleanup_dead();
1516 // Process any new sounds the player caused during their turn.
1517 for( npc &guy : all_npcs() ) {
1518 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1520 }
1521 }
1524 wait_popup.reset();
1526 }
1527
1528 if( queue_screenshot ) {
1532 queue_screenshot = false;
1533 }
1534
1535 if( handle_action() ) {
1537 u.action_taken();
1538 }
1539
1540 if( is_game_over() ) {
1541 return cleanup_at_end();
1542 }
1543
1544 if( uquit == QUIT_WATCH ) {
1545 break;
1546 }
1547 if( u.activity ) {
1549 }
1550 }
1551 // Reset displayed sound markers now that the turn is over.
1552 // We only want this to happen if the player had a chance to examine the sounds.
1554 }
1555 }
1556
1557 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1558 // Still have a view offset, but might not be driving anymore,
1559 // or the option has been deactivated,
1560 // might also happen when someone dives from a moving car.
1561 // or when using the handbrake.
1562 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1563 calc_driving_offset( veh );
1564 }
1565
1566 // No-scent debug mutation has to be processed here or else it takes time to start working
1567 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1568 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1571 }
1572 scent.update( u.pos(), m );
1573
1574 // We need floor cache before checking falling 'n stuff
1576
1579 m.vehmove();
1580 m.process_fields();
1581 m.process_items();
1584
1585 // Apply sounds from previous turn to monster and NPC AI.
1587 // Update vision caches for monsters. If this turns out to be expensive,
1588 // consider a stripped down cache just for monsters.
1589 m.build_map_cache( get_levz(), true );
1590 monmove();
1591 if( calendar::once_every( 5_minutes ) ) {
1593 }
1594 if( calendar::once_every( 10_seconds ) ) {
1595 for( const tripoint &elem : m.get_furn_field_locations() ) {
1596 const auto &furn = m.furn( elem ).obj();
1597 for( const emit_id &e : furn.emissions ) {
1598 m.emit_field( elem, e );
1599 }
1600 }
1601 }
1604 u.process_turn();
1605
1607 cleanup_dead();
1608
1609 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1612 }
1613
1614 if( get_levz() >= 0 && !u.is_underwater() ) {
1615 handle_weather_effects( weather.weather_id );
1616 }
1617
1618 const bool player_is_sleeping = u.has_effect( effect_sleep );
1619 bool wait_redraw = false;
1620 std::string wait_message;
1621 time_duration wait_refresh_rate;
1622 if( player_is_sleeping ) {
1623 wait_redraw = true;
1624 wait_message = _( "Wait till you wake up…" );
1625 wait_refresh_rate = 30_minutes;
1626 if( calendar::once_every( 1_hours ) ) {
1628 }
1629 } else if( u.has_destination() ) {
1630 wait_redraw = true;
1631 wait_message = _( "Travelling…" );
1632 wait_refresh_rate = 15_turns;
1633 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1634 wait_redraw = true;
1635 wait_message = *progress;
1636 if( u.activity.id() == ACT_AUTODRIVE ) {
1637 wait_refresh_rate = 1_turns;
1638 } else {
1639 wait_refresh_rate = 5_minutes;
1640 }
1641 }
1642 if( wait_redraw ) {
1644 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1645 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1647 }
1648
1649 // Avoid redrawing the main UI every time due to invalidation
1651 wait_popup = std::make_unique<static_popup>();
1652 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1656 }
1657 } else {
1658 // Nothing to wait for now
1659 wait_popup.reset();
1661 }
1662
1664 u.update_body_wetness( get_weather().get_precise() );
1665 u.apply_wetness_morale( weather.temperature );
1666
1667 if( calendar::once_every( 1_minutes ) ) {
1668 u.update_morale();
1669 }
1670
1671 if( calendar::once_every( 9_turns ) ) {
1673 }
1674
1675 if( !u.is_deaf() ) {
1677 }
1682
1683 // reset player noise
1684 u.volume = 0;
1685
1686 return false;
1687}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:9010
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:872
bool check_mount_is_spooked()
Definition: character.cpp:1097
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5194
bool is_mounted() const
Definition: character.cpp:1138
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8769
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9137
bool is_deaf() const
Definition: character.cpp:4498
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4676
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1885
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1805
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:12412
void overmap_npc_move()
Definition: game.cpp:4535
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12522
void monmove()
Definition: game.cpp:4410
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1751
void add_artifact_dreams()
Definition: game.cpp:12356
int moves_since_last_save
Definition: game.h:1088
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7418
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1332
bool cleanup_at_end()
Definition: game.cpp:1028
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1124
bool queue_screenshot
Definition: game.h:1067
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11845
void process_activity()
Definition: game.cpp:1740
void update_stair_monsters()
Definition: game.cpp:11333
void process_voluntary_act_interrupt()
Definition: game.cpp:1701
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:896
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1095
void cleanup_dead()
Definition: game.cpp:4375
bool is_game_over()
Definition: game.cpp:2689
void perhaps_add_random_npc()
Definition: game.cpp:11580
void mon_info_update()
Definition: game.cpp:4180
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:7906
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2269
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1925
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7604
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7563
void vehmove()
Definition: map.cpp:410
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1560
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1343
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8034
void process_items()
Definition: map.cpp:4559
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:924
int volume
Definition: player.h:684
int scent
Definition: player.h:694
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1711
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:319
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:151
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1159
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3461 of file game.cpp.

3462{
3463 if( test_mode ) {
3464 return;
3465 }
3466
3467 //temporary fix for updating visibility for minimap
3468 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3471
3472 werase( w_terrain );
3473 draw_ter();
3474 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3475 shared_ptr_fast<draw_callback_t> cb = it->lock();
3476 if( cb ) {
3477 ( *cb )();
3478 ++it;
3479 } else {
3480 it = draw_callbacks.erase( it );
3481 }
3482 }
3484
3485 draw_panels( true );
3486}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1034
void draw_panels(bool force_draw=false)
Definition: game.cpp:3488
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3602
void update_visibility_cache(int zlev)
Definition: map.cpp:5574
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 955 of file animation.cpp.

956{
957}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 510 of file animation.cpp.

512{
513 draw_bullet_curses( m, t, bullet, &trajectory[i] );
514}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:451
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3584 of file game.cpp.

3585{
3586 draw_critter_internal( w_terrain, critter, center, false, m, u );
3587}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3551

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3589 of file game.cpp.

3590{
3591 draw_critter_internal( w_terrain, critter, center, true, m, u );
3592}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 716 of file animation.cpp.

717{
718 const tripoint rp = relative_view_pos( *this, p );
719 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
720}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:119
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 911 of file animation.cpp.

912{
913}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 872 of file animation.cpp.

873{
874}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 885 of file animation.cpp.

886{
887}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 729 of file animation.cpp.

730{
731 // Do nothing
732}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 573 of file animation.cpp.

574{
575 draw_hit_mon_curses( p, m, u, dead );
576}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:544

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 618 of file animation.cpp.

619{
620 draw_hit_player_curses( *this, p, dam );
621}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:581

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 925 of file animation.cpp.

927{
928}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 702 of file animation.cpp.

703{
704 draw_line_curses( *this, points );
705}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:682

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 669 of file animation.cpp.

671{
672 if( !u.sees( p ) ) {
673 return;
674 }
675
676 draw_line_curses( *this, center, points, noreveal );
677}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5963 of file game.cpp.

5964{
5965 if( !liveview.is_enabled() ) {
5966#if defined( TILES )
5967 if( is_draw_tiles_mode() ) {
5968 draw_cursor( lp );
5969 return;
5970 }
5971#endif
5972 const tripoint view_center = u.pos() + u.view_offset;
5973 visibility_type visibility = VIS_HIDDEN;
5974 const bool inbounds = m.inbounds( lp );
5975 if( inbounds ) {
5976 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5977 }
5978 if( visibility == VIS_CLEAR ) {
5979 const Creature *const creature = critter_at( lp, true );
5980 if( creature != nullptr && u.sees( *creature ) ) {
5981 creature->draw( w_terrain, view_center, true );
5982 } else {
5983 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5984 }
5985 } else {
5986 std::string visibility_indicator;
5987 nc_color visibility_indicator_color = c_white;
5988 switch( visibility ) {
5989 case VIS_CLEAR:
5990 // Already handled by the outer if statement
5991 break;
5992 case VIS_BOOMER:
5993 case VIS_BOOMER_DARK:
5994 visibility_indicator = '#';
5995 visibility_indicator_color = c_pink;
5996 break;
5997 case VIS_DARK:
5998 visibility_indicator = '#';
5999 visibility_indicator_color = c_dark_gray;
6000 break;
6001 case VIS_LIT:
6002 visibility_indicator = '#';
6003 visibility_indicator_color = c_light_gray;
6004 break;
6005 case VIS_HIDDEN:
6006 visibility_indicator = 'x';
6007 visibility_indicator_color = c_white;
6008 break;
6009 }
6010
6011 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
6012 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
6013 }
6014 }
6015}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:716
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4846
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7614
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5620
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:698
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5798
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:176

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3662 of file game.cpp.

3663{
3664
3665 // Draw the box
3666 werase( w_minimap );
3668
3669 const tripoint_abs_omt curs = u.global_omt_location();
3670 const point_abs_omt curs2( curs.xy() );
3672 bool drew_mission = targ == overmap::invalid_tripoint;
3673
3674 for( int i = -2; i <= 2; i++ ) {
3675 for( int j = -2; j <= 2; j++ ) {
3676 const point_abs_omt om( curs2 + point( i, j ) );
3677 nc_color ter_color;
3678 tripoint_abs_omt omp( om, get_levz() );
3679 std::string ter_sym;
3680 const bool seen = overmap_buffer.seen( omp );
3681 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3682 if( overmap_buffer.has_note( omp ) ) {
3683
3684 const std::string &note_text = overmap_buffer.note( omp );
3685
3686 ter_color = c_yellow;
3687 ter_sym = "N";
3688
3689 int symbolIndex = note_text.find( ':' );
3690 int colorIndex = note_text.find( ';' );
3691
3692 bool symbolFirst = symbolIndex < colorIndex;
3693
3694 if( colorIndex > -1 && symbolIndex > -1 ) {
3695 if( symbolFirst ) {
3696 if( colorIndex > 4 ) {
3697 colorIndex = -1;
3698 }
3699 if( symbolIndex > 1 ) {
3700 symbolIndex = -1;
3701 colorIndex = -1;
3702 }
3703 } else {
3704 if( symbolIndex > 4 ) {
3705 symbolIndex = -1;
3706 }
3707 if( colorIndex > 2 ) {
3708 colorIndex = -1;
3709 }
3710 }
3711 } else if( colorIndex > 2 ) {
3712 colorIndex = -1;
3713 } else if( symbolIndex > 1 ) {
3714 symbolIndex = -1;
3715 }
3716
3717 if( symbolIndex > -1 ) {
3718 int symbolStart = 0;
3719 if( colorIndex > -1 && !symbolFirst ) {
3720 symbolStart = colorIndex + 1;
3721 }
3722 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3723 }
3724
3725 if( colorIndex > -1 ) {
3726
3727 int colorStart = 0;
3728
3729 if( symbolIndex > -1 && symbolFirst ) {
3730 colorStart = symbolIndex + 1;
3731 }
3732
3733 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3734
3735 if( sym.length() == 2 ) {
3736 if( sym == "br" ) {
3737 ter_color = c_brown;
3738 } else if( sym == "lg" ) {
3739 ter_color = c_light_gray;
3740 } else if( sym == "dg" ) {
3741 ter_color = c_dark_gray;
3742 }
3743 } else {
3744 char colorID = sym.c_str()[0];
3745 if( colorID == 'r' ) {
3746 ter_color = c_light_red;
3747 } else if( colorID == 'R' ) {
3748 ter_color = c_red;
3749 } else if( colorID == 'g' ) {
3750 ter_color = c_light_green;
3751 } else if( colorID == 'G' ) {
3752 ter_color = c_green;
3753 } else if( colorID == 'b' ) {
3754 ter_color = c_light_blue;
3755 } else if( colorID == 'B' ) {
3756 ter_color = c_blue;
3757 } else if( colorID == 'W' ) {
3758 ter_color = c_white;
3759 } else if( colorID == 'C' ) {
3760 ter_color = c_cyan;
3761 } else if( colorID == 'c' ) {
3762 ter_color = c_light_cyan;
3763 } else if( colorID == 'P' ) {
3764 ter_color = c_pink;
3765 } else if( colorID == 'm' ) {
3766 ter_color = c_magenta;
3767 }
3768 }
3769 }
3770 } else if( !seen ) {
3771 ter_sym = " ";
3772 ter_color = c_black;
3773 } else if( vehicle_here ) {
3774 ter_color = c_cyan;
3775 ter_sym = "c";
3776 } else {
3777 const oter_id &cur_ter = overmap_buffer.ter( omp );
3778 ter_sym = cur_ter->get_symbol();
3779 if( overmap_buffer.is_explored( omp ) ) {
3780 ter_color = c_dark_gray;
3781 } else {
3782 ter_color = cur_ter->get_color();
3783 }
3784 }
3785 if( !drew_mission && targ.xy() == omp.xy() ) {
3786 // If there is a mission target, and it's not on the same
3787 // overmap terrain as the player character, mark it.
3788 // TODO: Inform player if the mission is above or below
3789 drew_mission = true;
3790 if( i != 0 || j != 0 ) {
3791 ter_color = red_background( ter_color );
3792 }
3793 }
3794 if( i == 0 && j == 0 ) {
3795 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3796 } else {
3797 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3798 }
3799 }
3800 }
3801
3802 // Print arrow to mission if we have one!
3803 if( !drew_mission ) {
3804 double slope = curs2.x() != targ.x() ?
3805 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3806
3807 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3808 if( targ.y() > curs2.y() ) {
3809 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3810 } else {
3811 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3812 }
3813 } else {
3814 int arrowx = -1;
3815 int arrowy = -1;
3816 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3817 arrowy = targ.y() > curs2.y() ? 6 : 0;
3818 arrowx =
3819 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3820 if( arrowx < 0 ) {
3821 arrowx = 0;
3822 }
3823 if( arrowx > 6 ) {
3824 arrowx = 6;
3825 }
3826 } else {
3827 arrowx = targ.x() > curs2.x() ? 6 : 0;
3828 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3829 if( arrowy < 0 ) {
3830 arrowy = 0;
3831 }
3832 if( arrowy > 6 ) {
3833 arrowy = 6;
3834 }
3835 }
3836 char glyph = '*';
3837 if( targ.z() > u.posz() ) {
3838 glyph = '^';
3839 } else if( targ.z() < u.posz() ) {
3840 glyph = 'v';
3841 }
3842
3843 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3844 }
3845 }
3846
3847 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3848 for( int i = -3; i <= 3; i++ ) {
3849 for( int j = -3; j <= 3; j++ ) {
3850 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3851 continue; // only do hordes on the border, skip inner map
3852 }
3853 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3855 if( overmap_buffer.seen( omp )
3856 && g->u.overmap_los( omp, sight_points ) ) {
3857 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3858 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3859 }
3860 }
3861 }
3862 }
3863
3865}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:196
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:213
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:221

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 969 of file animation.cpp.

971{
972}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3488 of file game.cpp.

3489{
3490 static int previous_turn = -1;
3491 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3492 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3493 auto &mgr = panel_manager::get_manager();
3494 int y = 0;
3495 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3496 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3497 int log_height = 0;
3498 for( const window_panel &panel : mgr.get_current_layout() ) {
3499 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3500 log_height += panel.get_height() + spacer;
3501 }
3502 }
3503 log_height = std::max( TERMY - log_height, 3 );
3504 for( const window_panel &panel : mgr.get_current_layout() ) {
3505 if( panel.render() ) {
3506 // height clamped to window height.
3507 int h = std::min( panel.get_height(), TERMY - y );
3508 if( h == -2 ) {
3509 h = log_height;
3510 }
3511 h += spacer;
3512 if( panel.toggle && panel.render() && h > 0 ) {
3513 if( panel.always_draw || draw_this_turn ) {
3514 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3515 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3516 }
3517 if( show_panel_adm ) {
3518 const std::string panel_name = _( panel.get_name() );
3519 const int panel_name_width = utf8_width( panel_name );
3520 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3521 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3522 werase( label );
3523 mvwprintz( label, point_zero, c_light_red, panel_name );
3525 label = catacurses::newwin( h, 1,
3526 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3527 werase( label );
3528 if( h == 1 ) {
3530 } else {
3532 for( int i = 1; i < h - 1; i++ ) {
3534 }
3535 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3536 }
3538 }
3539 y += h;
3540 }
3541 }
3542 }
3543 previous_turn = current_turn;
3544}
bool show_panel_adm
Definition: game.h:1062
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3546 of file game.cpp.

3547{
3548 w_pixel_minimap = w;
3549}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 846 of file animation.cpp.

847{
848}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 797 of file animation.cpp.

798{
799 draw_sct_curses( *this );
800}
void draw_sct_curses(const game &g)
Definition: animation.cpp:764

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3602 of file game.cpp.

3603{
3605 draw_sounds );
3606}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3608 of file game.cpp.

3609{
3611
3612 m.draw( w_terrain, center );
3613
3614 if( draw_sounds ) {
3616 }
3617
3618 for( Creature &critter : all_creatures() ) {
3619 draw_critter( critter, center );
3620 }
3621
3622 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3623 // Draw auto-move preview trail
3624 const tripoint &final_destination = destination_preview.back();
3625 tripoint line_center = u.pos() + u.view_offset;
3626 draw_line( final_destination, line_center, destination_preview, true );
3627 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3628 POSY - u.posy() ), c_white, 'X' );
3629 }
3630
3631 if( u.controlling_vehicle && !looking ) {
3632 draw_veh_dir_indicator( false );
3633 draw_veh_dir_indicator( true );
3634 }
3635 // Place the cursor over the player as is expected by screen readers.
3636 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3637}
int posx() const override
Definition: character.h:838
int posy() const override
Definition: character.h:841
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3584
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12512
std::vector< tripoint > destination_preview
Definition: game.h:1114
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3654
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:669
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5670
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3274
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 859 of file animation.cpp.

860{
861}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7266 of file game.cpp.

7267{
7268 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7269}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7236

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 898 of file animation.cpp.

899{
900}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3654 of file game.cpp.

3655{
3656 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3657 auto col = next ? c_white : c_dark_gray;
3658 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3659 }
3660}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3639

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 941 of file animation.cpp.

943{
944}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 756 of file animation.cpp.

757{
759}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:737

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 832 of file animation.cpp.

833{
834 draw_zones_curses( w_terrain, start, end, offset );
835}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8308 of file game.cpp.

8309{
8311}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2503
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8313 of file game.cpp.

8314{
8315 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8316 u.drop( game_menus::inv::multidrop( u ), *pnt );
8317 }
8318}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 37 of file dump.cpp.

39{
40 try {
41 loading_ui ui( false );
43 load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
45 } catch( const std::exception &err ) {
46 std::cerr << "Error loading data from json: " << err.what() << std::endl;
47 return false;
48 }
49
50 std::vector<std::string> header;
51 std::vector<std::vector<std::string>> rows;
52
53 int scol = 0; // sorting column
54
55 std::map<std::string, standard_npc> test_npcs;
56 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
57 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
58 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
59 4, 8, 8, 8, 10 /* PER 10 */ );
60 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
61 4, 10, 8, 8, 8 /* STAT 10 */ );
62 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
65 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
66
67 std::map<std::string, item> test_items;
68 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
71 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
72 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
73
74 if( what == "AMMO" ) {
75 header = {
76 "Name", "Ammo", "Volume", "Weight", "Stack",
77 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
78 };
79 auto dump = [&rows]( const item & obj ) {
80 std::vector<std::string> r;
81 r.push_back( obj.tname( 1, false ) );
82 r.push_back( obj.ammo_type().str() );
83 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
84 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
85 r.push_back( std::to_string( obj.type->stack_size ) );
86 r.push_back( std::to_string( obj.type->ammo->range ) );
87 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
88 r.push_back( std::to_string( obj.type->ammo->recoil ) );
89 damage_instance damage = obj.type->ammo->damage;
90 r.push_back( std::to_string( damage.total_damage() ) );
91 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
92 rows.push_back( r );
93 };
94 for( const itype *e : item_controller->all() ) {
95 if( e->ammo ) {
96 dump( item( e, calendar::turn, item::solitary_tag {} ) );
97 }
98 }
99
100 } else if( what == "ARMOR" ) {
101 header = {
102 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
103 };
104 auto dump = [&rows]( const item & obj ) {
105 std::vector<std::string> r;
106 r.push_back( obj.tname( 1, false ) );
107 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
108 r.push_back( std::to_string( obj.get_warmth() ) );
109 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
110 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
111 r.push_back( std::to_string( obj.get_coverage() ) );
112 r.push_back( std::to_string( obj.bash_resist() ) );
113 r.push_back( std::to_string( obj.cut_resist() ) );
114 r.push_back( std::to_string( obj.bullet_resist() ) );
115 r.push_back( std::to_string( obj.acid_resist() ) );
116 r.push_back( std::to_string( obj.fire_resist() ) );
117 rows.push_back( r );
118 };
119
120 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
121
122 for( const itype *e : item_controller->all() ) {
123 if( e->armor ) {
124 item obj( e );
125 if( bp == num_bp || obj.covers( bp ) ) {
126 if( obj.has_flag( flag_VARSIZE ) ) {
127 obj.set_flag( "FIT" );
128 }
129 dump( obj );
130 }
131 }
132 }
133
134 } else if( what == "EDIBLE" ) {
135 header = {
136 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
137 };
138 for( const auto &v : vitamin::all() ) {
139 header.push_back( v.second.name() );
140 }
141 auto dump = [&rows]( const item & obj ) {
142 std::vector<std::string> r;
143 r.push_back( obj.tname( 1, false ) );
144 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
145 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
146 r.push_back( std::to_string( obj.type->stack_size ) );
147 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
148 r.push_back( std::to_string( obj.get_comestible()->quench ) );
149 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
150 auto vits = obj.get_comestible()->default_nutrition.vitamins;
151 for( const auto &v : vitamin::all() ) {
152 r.push_back( std::to_string( vits[ v.first ] ) );
153 }
154 rows.push_back( r );
155 };
156
157 for( const itype *e : item_controller->all() ) {
159
160 if( food.is_food() && g->u.can_eat( food ).success() ) {
161 dump( food );
162 }
163 }
164
165 } else if( what == "GUN" ) {
166 header = {
167 "Name", "Ammo", "Volume", "Weight", "Capacity",
168 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
169 "Aim time", "Effective range", "Snapshot range", "Max range"
170 };
171
172 std::set<std::string> locations;
173 for( const itype *e : item_controller->all() ) {
174 if( e->gun ) {
175 std::transform( e->gun->valid_mod_locations.begin(),
176 e->gun->valid_mod_locations.end(),
177 std::inserter( locations, locations.begin() ),
178 []( const std::pair<gunmod_location, int> &q ) {
179 return q.first.name();
180 } );
181 }
182 }
183 for( const auto &e : locations ) {
184 header.push_back( e );
185 }
186
187 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
188 std::vector<std::string> r;
189 r.push_back( obj.tname( 1, false ) );
190 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
191 obj.ammo_types().end(), []( const ammotype & at ) {
192 return at.str();
194 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
195 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
196 r.push_back( std::to_string( obj.ammo_capacity() ) );
197 r.push_back( std::to_string( obj.gun_range() ) );
198 r.push_back( std::to_string( obj.gun_dispersion() ) );
199 r.push_back( std::to_string( obj.gun_recoil() ) );
200 damage_instance damage = obj.gun_damage();
201 r.push_back( std::to_string( damage.total_damage() ) );
202 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
203
204 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
205
206 for( const auto &e : locations ) {
207 const auto &vml = obj.type->gun->valid_mod_locations;
208 const auto iter = vml.find( e );
209 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
210 }
211 rows.push_back( r );
212 };
213 for( const itype *e : item_controller->all() ) {
214 if( e->gun ) {
215 item gun( e );
216 if( !gun.magazine_integral() ) {
217 gun.put_in( item( gun.magazine_default() ) );
218 }
219 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
220
221 dump( test_npcs[ "S1" ], gun );
222
223 if( gun.type->gun->barrel_length > 0_ml ) {
224 gun.put_in( item( "barrel_small" ) );
225 dump( test_npcs[ "S1" ], gun );
226 }
227 }
228 }
229
230 } else if( what == "RECIPE" ) {
231
232 // optionally filter recipes to include only those using specified skills
233 recipe_subset dict;
234 for( const auto &r : recipe_dict ) {
235 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
236 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
237 return true;
238 }
239 const auto iter = r.second.required_skills.find( skill_id( s ) );
240 return iter != r.second.required_skills.end() && iter->second > 0;
241 } ) ) {
242 dict.include( &r.second );
243 }
244 }
245
246 // only consider skills that are required by at least one recipe
247 std::vector<Skill> sk;
248 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
249 std::back_inserter( sk ), [&dict]( const Skill & s ) {
250 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
251 return r->skill_used == s.ident() ||
252 r->required_skills.find( s.ident() ) != r->required_skills.end();
253 } );
254 } );
255
256 header = { "Result" };
257
258 for( const auto &e : sk ) {
259 header.push_back( e.ident().str() );
260 }
261
262 for( const recipe *e : dict ) {
263 std::vector<std::string> r;
264 r.push_back( e->result_name() );
265 for( const auto &s : sk ) {
266 if( e->skill_used == s.ident() ) {
267 r.push_back( std::to_string( e->difficulty ) );
268 } else {
269 auto iter = e->required_skills.find( s.ident() );
270 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
271 }
272 }
273 rows.push_back( r );
274 }
275
276 } else if( what == "VEHICLE" ) {
277 header = {
278 "Name", "Weight (empty)", "Weight (fueled)",
279 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
280 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
281 };
282 auto dump = [&rows]( const vproto_id & obj ) {
283 vehicle veh_empty( obj, 0, 0 );
284 vehicle veh_fueled( obj, 100, 0 );
285
286 std::vector<std::string> r;
287 r.push_back( veh_empty.name );
288 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
289 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
290 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
294 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
295 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
296 r.push_back( std::to_string( static_cast<int>( 50 *
297 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
298 rows.push_back( r );
299 };
300 for( auto &e : vehicle_prototype::get_all() ) {
301 dump( e );
302 }
303
304 } else if( what == "VPART" ) {
305 header = {
306 "Name", "Location", "Weight", "Size"
307 };
308 auto dump = [&rows]( const vpart_info & obj ) {
309 std::vector<std::string> r;
310 r.push_back( obj.name() );
311 r.push_back( obj.location );
312 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
313 r.push_back( std::to_string( w ) );
314 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
315 rows.push_back( r );
316 };
317 for( const auto &e : vpart_info::all() ) {
318 dump( e.second );
319 }
320
321 } else {
322 std::cerr << "unknown argument: " << what << std::endl;
323 return false;
324 }
325
326 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
327 return e.empty();
328 } ), rows.end() );
329
330 if( scol >= 0 ) {
331 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
332 const std::vector<std::string> &rhs ) {
333 return localized_compare( lhs[ scol ], rhs[ scol ] );
334 } );
335 }
336
337 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
338
339 switch( mode ) {
340 case dump_mode::TSV:
341 rows.insert( rows.begin(), header );
342 for( const auto &r : rows ) {
343 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
344 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
345 std::cout << r.back() << "\n";
346 }
347 break;
348
349 case dump_mode::HTML:
350 std::cout << "<table>";
351
352 std::cout << "<thead>";
353 std::cout << "<tr>";
354 for( const auto &col : header ) {
355 std::cout << "<th>" << col << "</th>";
356 }
357 std::cout << "</tr>";
358 std::cout << "</thead>";
359
360 std::cout << "<tdata>";
361 for( const auto &r : rows ) {
362 std::cout << "<tr>";
363 for( const auto &col : r ) {
364 std::cout << "<td>" << col << "</td>";
365 }
366 std::cout << "</tr>";
367 }
368 std::cout << "</tdata>";
369
370 std::cout << "</table>";
371 break;
372 }
373
374 return true;
375}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2979
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4833
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:986
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:586
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1588
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:679
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:196
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157
string_id< MOD_INFORMATION > mod_id
Definition: type_id.h:91

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 3089 of file game.cpp.

3090{
3091 return *event_bus_ptr;
3092}
pimpl< event_bus > event_bus_ptr
Definition: game.h:1001

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5284 of file game.cpp.

5285{
5286 if( veh.magic ) {
5287 add_msg( m_info, _( "This is your %s" ), veh.name );
5288 return;
5289 }
5290 auto act = veh_interact::run( veh, c );
5291 if( act ) {
5292 u.moves = 0;
5294 }
5295}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1846
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5664 of file game.cpp.

5665{
5666 // if we are driving a vehicle, examine the
5667 // current tile without asking.
5668 const optional_vpart_position vp = m.veh_at( u.pos() );
5669 if( vp && vp->vehicle().player_in_control( u ) ) {
5670 examine( u.pos() );
5671 return;
5672 }
5673
5674 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5675 _( "There is nothing that can be examined nearby." ),
5676 ACTION_EXAMINE, false );
5677 if( !examp_ ) {
5678 return;
5679 }
5680 u.manual_examine = true;
5681 examine( *examp_ );
5682 u.manual_examine = false;
5683}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1019
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5664
bool manual_examine
Definition: player.h:698

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5752 of file game.cpp.

5753{
5754 if( disable_robot( examp ) ) {
5755 return;
5756 }
5757
5758 Creature *c = critter_at( examp );
5759 if( c != nullptr ) {
5760 monster *mon = dynamic_cast<monster *>( c );
5761 if( mon != nullptr ) {
5762 add_msg( _( "There is a %s." ), mon->get_name() );
5763 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5764 if( monexamine::pet_menu( *mon ) ) {
5765 return;
5766 }
5767 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5768 if( monexamine::mech_hack( *mon ) ) {
5769 return;
5770 }
5771 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5772 if( monexamine::pay_bot( *mon ) ) {
5773 return;
5774 }
5775 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5776 if( monexamine::mfriend_menu( *mon ) ) {
5777 return;
5778 }
5779 }
5780 } else if( u.is_mounted() ) {
5781 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5782 }
5783 npc *np = dynamic_cast<npc *>( c );
5784 if( np != nullptr && !u.is_mounted() ) {
5785 if( npc_menu( *np ) ) {
5786 return;
5787 }
5788 } else if( np != nullptr && u.is_mounted() ) {
5789 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5790 }
5791 }
5792
5793 const optional_vpart_position vp = m.veh_at( examp );
5794 if( vp && u.is_mounted() ) {
5795 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5796 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5797 } else {
5798 vp->vehicle().interact_with( examp, vp->part_index() );
5799 return;
5800 }
5801 } else if( vp && !u.is_mounted() ) {
5802 vp->vehicle().interact_with( examp, vp->part_index() );
5803 return;
5804 }
5805
5806 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5807 use_computer( examp );
5808 return;
5809 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5810 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5811 }
5812 const furn_t &xfurn_t = m.furn( examp ).obj();
5813 const ter_t &xter_t = m.ter( examp ).obj();
5814
5815 const tripoint player_pos = u.pos();
5816
5817 if( m.has_furn( examp ) && !u.is_mounted() ) {
5818 xfurn_t.examine( u, examp );
5819 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5820 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5821 } else {
5822 if( !u.is_mounted() ) {
5823 xter_t.examine( u, examp );
5824 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5825 xter_t.examine( u, examp );
5826 } else {
5827 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5828 }
5829 }
5830
5831 // Did the player get moved? Bail out if so; our examp probably
5832 // isn't valid anymore.
5833 if( player_pos != u.pos() ) {
5834 return;
5835 }
5836
5837 bool none = true;
5838 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5839 none = false;
5840 }
5841
5842 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5843 iexamine::trap( u, examp );
5844 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5845 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5846 }
5847
5848 // In case of teleport trap or somesuch
5849 if( player_pos != u.pos() ) {
5850 return;
5851 }
5852
5853 // Feedback for fire lasting time, this can be judged while mounted
5854 const std::string fire_fuel = get_fire_fuel_string( examp );
5855 if( !fire_fuel.empty() ) {
5856 add_msg( fire_fuel );
5857 }
5858
5859 if( m.has_flag( "SEALED", examp ) ) {
5860 if( none ) {
5861 if( m.has_flag( "UNSTABLE", examp ) ) {
5862 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5863 } else {
5864 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5865 }
5866 }
5867 } else {
5868 //examp has no traps, is a container and doesn't have a special examination function
5869 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5870 m.has_flag( "CONTAINER", examp ) && none ) {
5871 add_msg( _( "It is empty." ) );
5872 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5873 xfurn_t.examine == &iexamine::fireplace ) ||
5874 xfurn_t.examine == &iexamine::workbench ) {
5875 return;
5876 } else {
5878 if( !u.is_mounted() ) {
5879 pickup::pick_up( examp, 0 );
5880 }
5881 }
5882 }
5883}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1622
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4814
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:9188
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5555
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1338
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5115
ter_id ter(const tripoint &p) const
Definition: map.cpp:1493
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1020
std::string get_name() const override
Definition: monster.cpp:487
static const efftype_id effect_pet("pet")
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5685
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2840
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6021
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:243
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3739
bool pet_menu(monster &z)
Definition: monexamine.cpp:64
bool mech_hack(monster &z)
Definition: monexamine.cpp:373
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:445
bool pay_bot(monster &z)
Definition: monexamine.cpp:405
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 50 of file descriptions.cpp.

51{
53 const int top = 3;
54 int width = 0;
55 catacurses::window w_head;
56 catacurses::window w_main;
57 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
58 const int left = 0;
59 const int right = TERMX;
60 const int bottom = TERMY;
61 width = right - left;
62 const int height = bottom - top;
63 w_head = catacurses::newwin( top, TERMX, point_zero );
64 w_main = catacurses::newwin( height, width, point( left, top ) );
65 ui.position( point_zero, point( TERMX, TERMY ) );
66 } );
67 ui.mark_resize();
68
69 // Default to critter (if any), furniture (if any), then terrain.
71 if( seen_critter( *this, p ) != nullptr ) {
73 } else if( get_map().has_furn( p ) ) {
75 }
76
77 std::string action;
78 input_context ctxt( "EXTENDED_DESCRIPTION" );
79 ctxt.register_action( "CREATURE" );
80 ctxt.register_action( "FURNITURE" );
81 ctxt.register_action( "TERRAIN" );
82 ctxt.register_action( "CONFIRM" );
83 ctxt.register_action( "QUIT" );
84 ctxt.register_action( "HELP_KEYBINDINGS" );
85
86 ui.on_redraw( [&]( const ui_adaptor & ) {
87 werase( w_head );
89 _( "[%s] describe creatures, [%s] describe furniture, "
90 "[%s] describe terrain, [%s] close." ),
91 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
92 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
93
94 // Set up line drawings
95 for( int i = 0; i < TERMX; i++ ) {
96 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
97 }
98
99 wnoutrefresh( w_head );
100
101 std::string desc;
102 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
103 switch( cur_target ) {
105 const Creature *critter = seen_critter( *this, p );
106 if( critter != nullptr ) {
107 desc = critter->extended_description();
108 } else {
109 desc = _( "You do not see any creature here." );
110 }
111 }
112 break;
114 if( !u.sees( p ) || !m.has_furn( p ) ) {
115 desc = _( "You do not see any furniture here." );
116 } else {
117 const furn_id fid = m.furn( p );
118 desc = fid.obj().extended_description();
119 }
120 break;
122 if( !u.sees( p ) ) {
123 desc = _( "You can't see the terrain here." );
124 } else {
125 const ter_id tid = m.ter( p );
126 desc = tid.obj().extended_description();
127 }
128 break;
129 }
130
131 std::string signage = m.get_signage( p );
132 if( !signage.empty() ) {
133 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
134 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
135 signage );
136 }
137
138 werase( w_main );
139 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
140 wnoutrefresh( w_main );
141 } );
142
143 do {
145 action = ctxt.handle_input();
146 if( action == "CREATURE" ) {
147 cur_target = description_target::creature;
148 } else if( action == "FURNITURE" ) {
150 } else if( action == "TERRAIN" ) {
151 cur_target = description_target::terrain;
152 }
153 } while( action != "CONFIRM" && action != "QUIT" );
154}
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:142
std::string get_signage(const tripoint &p) const
Definition: map.cpp:3979
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::string extended_description() const

References _, action, c_light_gray, c_white, creature, map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 7200 of file game.cpp.

7201{
7202 std::map<std::string, map_item_stack> temp_items;
7203 std::vector<map_item_stack> ret;
7204 std::vector<std::string> item_order;
7205
7206 if( u.is_blind() ) {
7207 return ret;
7208 }
7209
7210 for( auto &points_p_it : closest_points_first( u.pos(), iRadius ) ) {
7211 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
7212 u.sees( points_p_it ) &&
7213 m.sees_some_items( points_p_it, u ) ) {
7214
7215 for( auto &elem : m.i_at( points_p_it ) ) {
7216 const std::string name = elem.tname();
7217 const tripoint relative_pos = points_p_it - u.pos();
7218
7219 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
7220 item_order.push_back( name );
7221 temp_items[name] = map_item_stack( &elem, relative_pos );
7222 } else {
7223 temp_items[name].add_at_pos( &elem, relative_pos );
7224 }
7225 }
7226 }
7227 }
7228
7229 for( auto &elem : item_order ) {
7230 ret.push_back( temp_items[elem] );
7231 }
7232
7233 return ret;
7234}
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6353
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), and u.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1953 of file game.cpp.

1954{
1955 return overmap_buffer.find_npc( id ).get();
1956}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10953 of file game.cpp.

10955{
10956 const int omtilesz = SEEX * 2;
10957 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10958 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10959 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10960
10961 // Try to find the stairs.
10963 int best = INT_MAX;
10964 const int movez = z_after - get_levz();
10965 const bool going_down_1 = movez == -1;
10966 const bool going_up_1 = movez == 1;
10967 // If there are stairs on the same x and y as we currently are, use those
10968 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10969 stairs.emplace( u.pos() + tripoint_below );
10970 }
10971 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10972 stairs.emplace( u.pos() + tripoint_above );
10973 }
10974 // We did not find stairs directly above or below, so search the map for them
10975 if( !stairs.has_value() ) {
10976 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10977 if( rl_dist( u.pos(), dest ) <= best &&
10978 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10979 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10980 mp.ter( dest ) == t_manhole_cover ) ) ||
10981 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10982 stairs.emplace( dest );
10983 best = rl_dist( u.pos(), dest );
10984 }
10985 }
10986 }
10987
10988 if( stairs.has_value() ) {
10989 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10990 npc *guy = dynamic_cast<npc *>( blocking_creature );
10991 monster *mon = dynamic_cast<monster *>( blocking_creature );
10992 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10993 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10994 std::string cr_name = blocking_creature->get_name();
10995 std::string msg;
10996 if( guy ) {
10997 //~ %s is the name of hostile NPC
10998 msg = string_format( _( "%s is in the way!" ), cr_name );
10999 } else {
11000 //~ %s is some monster
11001 msg = string_format( _( "There's a %s in the way!" ), cr_name );
11002 }
11003
11004 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
11005 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
11006 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
11007 add_msg( msg );
11008 return cata::nullopt;
11009 }
11010 }
11011 return stairs;
11012 }
11013
11014 // No stairs found! Try to make some
11015 rope_ladder = false;
11016 stairs.emplace( u.pos() );
11017 stairs->z = z_after;
11018 // Check the destination area for lava.
11019 if( mp.ter( *stairs ) == t_lava ) {
11020 if( movez < 0 &&
11021 !query_yn(
11022 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
11023 return cata::nullopt;
11024 } else if( movez > 0 &&
11025 !query_yn(
11026 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
11027 return cata::nullopt;
11028 }
11029
11030 return stairs;
11031 }
11032
11033 if( movez > 0 ) {
11034 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
11035 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
11036 return cata::nullopt;
11037 }
11038 }
11039 // Manhole covers need this to work
11040 // Maybe require manhole cover here and fail otherwise?
11041 return stairs;
11042 }
11043
11044 if( mp.impassable( *stairs ) ) {
11045 popup( _( "Halfway down, the way down becomes blocked off." ) );
11046 return cata::nullopt;
11047 }
11048
11049 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
11050 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
11051 rope_ladder = true;
11052 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
11053 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
11054 } else {
11055 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
11056 }
11057 } else {
11058 return cata::nullopt;
11059 }
11060 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
11061 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
11062 if( u.has_trait( trait_VINES2 ) ) {
11063 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
11064 rope_ladder = true;
11065 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
11066 u.mod_pain( 5 );
11067 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
11068 u.mod_stored_nutr( 10 );
11069 u.mod_thirst( 10 );
11070 } else {
11071 add_msg( _( "You gingerly descend using your vines." ) );
11072 }
11073 } else {
11074 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
11075 rope_ladder = true;
11076 u.mod_stored_nutr( 10 );
11077 u.mod_thirst( 10 );
11078 }
11079 } else {
11080 return cata::nullopt;
11081 }
11082 } else if( u.has_amount( itype_grapnel, 1 ) ) {
11083 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
11084 rope_ladder = true;
11086 } else {
11087 return cata::nullopt;
11088 }
11089 } else if( u.has_amount( itype_rope_30, 1 ) ) {
11090 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
11091 rope_ladder = true;
11093 } else {
11094 return cata::nullopt;
11095 }
11096 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
11097 return cata::nullopt;
11098 }
11099
11100 return stairs;
11101}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8417
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9636
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4426
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4316
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3354
T & emplace(Args &&... args)
Definition: optional.h:143
constexpr bool has_value() const noexcept
Definition: optional.h:120
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8079
bool impassable(const tripoint &p) const
Definition: map.cpp:1790
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8412
bool is_enemy() const
Definition: npc.cpp:2040
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:1092
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:10489
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 10314 of file game.cpp.

10316{
10317 if( c == nullptr ) {
10318 debugmsg( "game::fling_creature invoked on null target" );
10319 return;
10320 }
10321
10322 if( c->is_dead_state() ) {
10323 // Flinging a corpse causes problems, don't enable without testing
10324 return;
10325 }
10326
10327 if( c->is_hallucination() ) {
10328 // Don't fling hallucinations
10329 return;
10330 }
10331
10332 int steps = 0;
10333 bool thru = true;
10334 const bool is_u = ( c == &u );
10335 // Don't animate critters getting bashed if animations are off
10336 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
10337
10338 player *p = dynamic_cast<player *>( c );
10339
10340 tileray tdir( dir );
10341 int range = flvel / 10;
10342 tripoint pt = c->pos();
10343 while( range > 0 ) {
10344 c->underwater = false;
10345 // TODO: Check whenever it is actually in the viewport
10346 // or maybe even just redraw the changed tiles
10347 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
10348 tdir.advance();
10349 pt.x = c->posx() + tdir.dx();
10350 pt.y = c->posy() + tdir.dy();
10351 float force = 0;
10352
10353 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
10354 monster &critter = *mon_ptr;
10355 // Approximate critter's "stopping power" with its max hp
10356 force = std::min<float>( 1.5f * critter.type->hp, flvel );
10357 const int damage = rng( force, force * 2.0f ) / 6;
10358 c->impact( damage, pt );
10359 // Multiply zed damage by 6 because no body parts
10360 const int zed_damage = std::max( 0,
10361 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
10362 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
10363 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
10364 critter.check_dead_state();
10365 if( !critter.is_dead() ) {
10366 thru = false;
10367 }
10368 } else if( m.impassable( pt ) ) {
10369 if( !m.veh_at( pt ).obstacle_at_part() ) {
10370 force = std::min<float>( m.bash_strength( pt ), flvel );
10371 } else {
10372 // No good way of limiting force here
10373 // Keep it 1 less than maximum to make the impact hurt
10374 // but to keep the target flying after it
10375 force = flvel - 1;
10376 }
10377 const int damage = rng( force, force * 2.0f ) / 9;
10378 c->impact( damage, pt );
10379 if( m.is_bashable( pt ) ) {
10380 // Only go through if we successfully make the tile passable
10381 m.bash( pt, flvel );
10382 thru = m.passable( pt );
10383 } else {
10384 thru = false;
10385 }
10386 }
10387
10388 // If the critter dies during flinging, moving it around causes debugmsgs
10389 if( c->is_dead_state() ) {
10390 return;
10391 }
10392
10393 flvel -= force;
10394 if( thru ) {
10395 if( p != nullptr ) {
10396 if( p->in_vehicle ) {
10397 m.unboard_vehicle( p->pos() );
10398 }
10399 // If we're flinging the player around, make sure the map stays centered on them.
10400 if( is_u && !suppress_map_update ) {
10401 update_map( pt.x, pt.y );
10402 } else {
10403 p->setpos( pt );
10404 }
10405 } else if( !critter_at( pt ) ) {
10406 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
10407 // Just don't setpos if it happens - next iteration will do so
10408 // or the monster will stop a tile before the unpassable one
10409 c->setpos( pt );
10410 }
10411 } else {
10412 // Don't zero flvel - count this as slamming both the obstacle and the ground
10413 // although at lower velocity
10414 break;
10415 }
10416 range--;
10417 steps++;
10418 if( animate && ( seen || u.sees( *c ) ) ) {
10422 }
10423 }
10424
10425 // Fall down to the ground - always on the last reached tile
10426 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
10427 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
10428 // Didn't smash into a wall or a floor so only take the fall damage
10429 if( thru && trap_under_creature == tr_ledge ) {
10430 m.creature_on_trap( *c, false );
10431 } else {
10432 // Fall on ground
10433 int force = rng( flvel, flvel * 2 ) / 9;
10434 if( controlled ) {
10435 force = std::max( force / 2 - 5, 0 );
10436 }
10437 if( force > 0 ) {
10438 int dmg = c->impact( force, c->pos() );
10439 // TODO: Make landing damage the floor
10440 m.bash( c->pos(), dmg / 4, false, false, false );
10441 }
10442 // Always apply traps to creature i.e. bear traps, tele traps etc.
10443 m.creature_on_trap( *c, false );
10444 }
10445 } else {
10446 c->underwater = true;
10447 if( is_u ) {
10448 if( controlled ) {
10449 add_msg( _( "You dive into water." ) );
10450 } else {
10451 add_msg( m_warning, _( "You fall into water." ) );
10452 }
10453 }
10454 }
10455}
void setpos(const tripoint &p) override
Definition: character.h:856
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1836
point update_map(player &p)
Definition: game.cpp:11180
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2444
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3506
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1076
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2409
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8285
bool passable(const tripoint &p) const
Definition: map.cpp:1795
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1855
bool is_dead() const
Definition: monster.cpp:2753
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1636
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Definition: ui_manager.cpp:290
int hp
Definition: mtype.h:267
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::passable(), Character::pos(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5297 of file game.cpp.

5298{
5299 // TODO: Z
5300 const int &x = p.x;
5301 const int &y = p.y;
5302 const std::string &door_name = door_type.obj().name();
5303 // sed when player/monsters are knocked back and when moving items out of the way
5304 point kb( x, y );
5305 const auto valid_location = [&]( const tripoint & p ) {
5306 return g->is_empty( p );
5307 };
5309 valid_location ) ) {
5310 kb.x = -pos->x + x + x;
5311 kb.y = -pos->y + y + y;
5312 }
5313 const tripoint kbp( kb, p.z );
5314 if( kbp == p ) {
5315 // can't pushback any creatures anywhere, that means the door can't close.
5316 return false;
5317 }
5318 const bool can_see = u.sees( tripoint( x, y, p.z ) );
5319 player *npc_or_player = critter_at<player>( tripoint( x, y, p.z ), false );
5320 if( npc_or_player != nullptr ) {
5321 if( bash_dmg <= 0 ) {
5322 return false;
5323 }
5324 if( npc_or_player->is_npc() && can_see ) {
5325 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5326 } else if( npc_or_player->is_player() ) {
5327 add_msg( m_bad, _( "The %s hits you." ), door_name );
5328 }
5329 if( npc_or_player->activity ) {
5330 npc_or_player->cancel_activity();
5331 }
5332 // TODO: make the npc angry?
5333 npc_or_player->hitall( bash_dmg, 0, nullptr );
5334 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5335 // TODO: perhaps damage/destroy the gate
5336 // if the npc was really big?
5337 }
5338 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5339 monster &critter = *mon_ptr;
5340 if( bash_dmg <= 0 ) {
5341 return false;
5342 }
5343 if( can_see ) {
5344 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5345 }
5346 if( critter.type->size <= MS_SMALL ) {
5347 critter.die_in_explosion( nullptr );
5348 } else {
5349 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5350 critter.check_dead_state();
5351 }
5352 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5353 // big critters simply prevent the gate from closing
5354 // TODO: perhaps damage/destroy the gate
5355 // if the critter was really big?
5356 return false;
5357 }
5358 if( !critter.is_dead() ) {
5359 // Still alive? Move the critter away so the door can close
5360 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5361 if( critter_at( p ) ) {
5362 return false;
5363 }
5364 }
5365 }
5366 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5367 if( bash_dmg <= 0 ) {
5368 return false;
5369 }
5370 vp->vehicle().damage( vp->part_index(), bash_dmg );
5371 if( m.veh_at( p ) ) {
5372 // Check again in case all parts at the door tile
5373 // have been destroyed, if there is still a vehicle
5374 // there, the door can not be closed
5375 return false;
5376 }
5377 }
5378 if( bash_dmg < 0 && !m.i_at( point( x, y ) ).empty() ) {
5379 return false;
5380 }
5381 if( bash_dmg == 0 ) {
5382 for( auto &elem : m.i_at( point( x, y ) ) ) {
5383 if( elem.made_of( LIQUID ) ) {
5384 // Liquids are OK, will be destroyed later
5385 continue;
5386 } else if( elem.volume() < 250_ml ) {
5387 // Dito for small items, will be moved away
5388 continue;
5389 }
5390 // Everything else prevents the door from closing
5391 return false;
5392 }
5393 }
5394
5395 m.ter_set( point( x, y ), door_type );
5396 if( m.has_flag( "NOITEM", point( x, y ) ) ) {
5397 map_stack items = m.i_at( point( x, y ) );
5398 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5399 if( it->made_of( LIQUID ) ) {
5400 it = items.erase( it );
5401 continue;
5402 }
5403 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5404 if( can_see ) {
5405 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5406 } else {
5407 add_msg( m_warning, _( "Something shatters!" ) );
5408 }
5409 it = items.erase( it );
5410 continue;
5411 }
5412 m.add_item_or_charges( kbp, *it );
5413 it = items.erase( it );
5414 }
5415 }
5416 return true;
5417}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8685
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
Definition: game.cpp:4584
iterator erase(const_iterator it) override
Definition: map.cpp:148
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1634
void die_in_explosion(Creature *source)
Definition: monster.cpp:1650
bool is_npc() const override
Definition: player.h:131
bool is_player() const override
Definition: player.h:114
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:259

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, map::veh_at(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 627 of file game.cpp.

628{
629 return gamemode ? gamemode->id() : SGAME_NULL;
630}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12527 of file game.cpp.

12528{
12529 for( Creature &critter : all_creatures() ) {
12530 if( pred( critter ) ) {
12531 return &critter;
12532 }
12533 }
12534 return nullptr;
12535}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 12437 of file game.cpp.

12439{
12440 std::vector<Creature *> result;
12441 for( Creature &critter : all_creatures() ) {
12442 if( pred( critter ) ) {
12443 result.push_back( &critter );
12444 }
12445 }
12446 return result;
12447}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 12417 of file game.cpp.

12418{
12419 // The player is located in the middle submap of the map.
12421 const tripoint pos_om = sm_to_om_copy( sm );
12422 // TODO: fix point types
12423 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
12424}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8089
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9271 of file game.cpp.

9272{
9273 std::vector<std::string> harmful_stuff;
9274 const auto fields_here = m.field_at( u.pos() );
9275 for( const auto &e : m.field_at( dest_loc ) ) {
9276 // warn before moving into a dangerous field except when already standing within a similar field
9277 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
9278 harmful_stuff.push_back( e.second.name() );
9279 }
9280 }
9281
9282 if( !u.is_blind() ) {
9283 const trap &tr = m.tr_at( dest_loc );
9284 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
9285 true ) );
9286 // HACK: Hack for now, later ledge should stop being a trap
9287 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
9288 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
9289 if( !boardable ) {
9290 harmful_stuff.emplace_back( tr.name() );
9291 }
9292 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
9293 harmful_stuff.emplace_back( tr.name() );
9294 }
9295
9296 static const std::set< body_part > sharp_bps = {
9299 };
9300
9301 const auto sharp_bp_check = [this]( body_part bp ) {
9302 return u.immune_to( bp, { DT_CUT, 10 } );
9303 };
9304
9305 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
9306 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
9307 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
9308 harmful_stuff.emplace_back( m.name( dest_loc ) );
9309 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
9310 m.veh_at( dest_loc ) ) &&
9311 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
9312 harmful_stuff.emplace_back( m.name( dest_loc ) );
9313 }
9314
9315 }
9316
9317 return harmful_stuff;
9318}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:305
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6981
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5277
bool has_zlevels() const
Definition: map.h:1655
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:1075
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3971 of file game.cpp.

3972{
3973 // We're going to get the contiguous fishable terrain starting at
3974 // the provided fishing location (e.g. where a line was cast or a fish
3975 // trap was set), and then check whether or not fishable monsters are
3976 // actually in those locations. This will help us ensure that we're
3977 // getting our fish from the location that we're ACTUALLY fishing,
3978 // rather than just somewhere in the vicinity.
3979
3980 std::unordered_set<tripoint> visited;
3981
3982 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3983 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3984
3985 const inclusive_cuboid<tripoint> fishing_boundaries(
3986 fishing_boundary_min, fishing_boundary_max );
3987
3988 const auto get_fishable_terrain = [&]( tripoint starting_point,
3989 std::unordered_set<tripoint> &fishable_terrain ) {
3990 std::queue<tripoint> to_check;
3991 to_check.push( starting_point );
3992 while( !to_check.empty() ) {
3993 const tripoint current_point = to_check.front();
3994 to_check.pop();
3995
3996 // We've been here before, so bail.
3997 if( visited.find( current_point ) != visited.end() ) {
3998 continue;
3999 }
4000
4001 // This point is out of bounds, so bail.
4002 if( !fishing_boundaries.contains( current_point ) ) {
4003 continue;
4004 }
4005
4006 // Mark this point as visited.
4007 visited.emplace( current_point );
4008
4009 if( m.has_flag( "FISHABLE", current_point ) ) {
4010 fishable_terrain.emplace( current_point );
4011 to_check.push( current_point + point_south );
4012 to_check.push( current_point + point_north );
4013 to_check.push( current_point + point_east );
4014 to_check.push( current_point + point_west );
4015 }
4016 }
4017 return;
4018 };
4019
4020 // Starting at the provided location, get our fishable terrain
4021 // and populate a set with those locations which we'll then use
4022 // to determine if any fishable monsters are in those locations.
4023 std::unordered_set<tripoint> fishable_points;
4024 get_fishable_terrain( fish_pos, fishable_points );
4025
4026 return fishable_points;
4027}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 4029 of file game.cpp.

4031{
4032 std::vector<monster *> unique_fish;
4033 for( monster &critter : all_monsters() ) {
4034 // If it is fishable...
4035 if( critter.has_flag( MF_FISHABLE ) ) {
4036 const tripoint critter_pos = critter.pos();
4037 // ...and it is in a fishable location.
4038 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
4039 unique_fish.push_back( &critter );
4040 }
4041 }
4042 }
4043
4044 return unique_fish;
4045}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2050 of file game.cpp.

2051{
2052 return follower_ids;
2053}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 966 of file game.cpp.

967{
968 return *kill_tracker_ptr;
969}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 12402 of file game.cpp.

12403{
12404 return m.get_abs_sub().x;
12405}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 12407 of file game.cpp.

12408{
12409 return m.get_abs_sub().y;
12410}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7370 of file game.cpp.

7371{
7372 return moves_since_last_save;
7373}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 12449 of file game.cpp.

12450{
12451 std::vector<npc *> result;
12452 for( npc &guy : all_npcs() ) {
12453 if( pred( guy ) ) {
12454 result.push_back( &guy );
12455 }
12456 }
12457 return result;
12458}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12537 of file game.cpp.

12538{
12539 return get_world_base_save_path() + "/" + base64_encode( u.name );
12540}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12542

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 236 of file handle_action.cpp.

237{
238 input_context ctxt;
239 if( uquit == QUIT_WATCH ) {
240 ctxt = input_context( "DEFAULTMODE" );
241 ctxt.set_iso( true );
242 // The list of allowed actions in death-cam mode in game::handle_action
243 // *INDENT-OFF*
244 for( const action_id id : {
257 } ) {
258 ctxt.register_action( action_ident( id ) );
259 }
260 // *INDENT-ON*
261 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
262 } else {
264 }
265
267
268 user_turn current_turn;
269
270
271 // Checking early if we will need to handle animations
272 // If we do not need to handle animations that will not change as long as the user has not selected an action
273 // and we can handle it like we are not animating.
274 weather_printable wPrint;
275 bool animate_weather = false;
276 bool animate_sct = false;
277 bool do_animations = [&]() {
278 if( get_option<bool>( "ANIMATIONS" ) ) {
279 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
280
281 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
282 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
283
284#if defined(TILES)
285 // Always animate, minimap and terrain may have animations to run
286 return true;
287#else
288 // Otherwise we need to see if we actually should animate.
289 // Minimap and Terrain never animate in !TILES
290 return animate_weather || animate_sct || uquit == QUIT_WATCH;
291#endif
292 }
293 return false;
294 }
295 ();
296
297 if( do_animations ) {
298 ctxt.set_timeout( 125 );
299
301 make_shared_fast<game::draw_callback_t>( [&]() {
302 if( animate_weather ) {
303 draw_weather( wPrint );
304 }
305 if( animate_sct ) {
306 draw_sct();
307 }
308 } );
309 add_draw_callback( animation_cb );
310 invalidate_main_ui_adaptor(); // We want to redraw at least once.
311
312 do {
313 if( animate_weather ) {
315 generate_weather_anim_frame( get_weather().weather_id, wPrint );
316 }
317 // don't bother calculating SCT if we won't show it
318 if( animate_sct ) {
320
322
323 //Check for creatures on all drawing positions and offset if necessary
324 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
325 const direction oCurDir = iter->getDirecton();
326 const int width = utf8_width( iter->getText() );
327 for( int i = 0; i < width; ++i ) {
328 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
329 const Creature *critter = critter_at( tmp, true );
330
331 if( critter != nullptr && u.sees( *critter ) ) {
332 i = -1;
333 int iPos = iter->getStep() + iter->getStepOffset();
334 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
335 if( iter2->getDirecton() == oCurDir &&
336 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
337 if( iter2->getType() == "hp" ) {
338 iter2->advanceStepOffset();
339 }
340
341 iter2->advanceStepOffset();
342 iPos = iter2->getStep() + iter2->getStepOffset();
343 }
344 }
345 }
346 }
347 }
348
349 // Stop animation when done
350 animate_sct = !SCT.vSCT.empty();
351 }
352 // We don't cache these checks as their result may change after 1st redraw
354 // TODO: we redraw *everything* just to animate a couple blinking dots
355 // on the minimap or a few tiles.
356 // This is far from ideal, and can probably be done much cheaper
357 // (update only part of the screen? draw static parts into a texture?)
359 }
360
361 std::unique_ptr<static_popup> deathcam_msg_popup;
362 if( uquit == QUIT_WATCH ) {
363 deathcam_msg_popup = std::make_unique<static_popup>();
364 deathcam_msg_popup
365 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
366 .on_top( true );
367 }
368
370 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
371 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
372 ctxt.reset_timeout();
373 } else {
376 SCT.vSCT.clear();
377
378 ctxt.set_timeout( 125 );
379 while( handle_mouseview( ctxt, action ) ) {
380 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
381 break;
382 }
383 }
384 ctxt.reset_timeout();
385 }
386
387 return ctxt;
388}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:67
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:257
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1136
bool minimap_requires_animation()
Definition: animation.cpp:1127
void draw_sct()
Definition: animation.cpp:797
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:756
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3384
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2323
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:947
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2423
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1862 of file game.cpp.

1863{
1864 return seed;
1865}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7375 of file game.cpp.

7376{
7377 return user_action_counter;
7378}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3639 of file game.cpp.

3640{
3641 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3642 return cata::nullopt;
3643 }
3644 const optional_vpart_position vp = m.veh_at( u.pos() );
3645 if( !vp ) {
3646 return cata::nullopt;
3647 }
3648 vehicle *const veh = &vp->vehicle();
3649 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3650 float r = 10.0;
3651 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3652}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12542 of file game.cpp.

12543{
12544 if( world_generator->active_world == nullptr ) {
12545 return PATH_INFO::savedir();
12546 }
12547 return world_generator->active_world->folder_path();
12548}
std::string savedir()
Definition: path_info.cpp:250

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7361 of file game.cpp.

7362{
7363#if defined(TILES)
7364 return tileset_zoom;
7365#else
7366 return DEFAULT_TILESET_ZOOM;
7367#endif
7368}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 10074 of file game.cpp.

10075{
10076 // Furniture: pull, push, or standing still and nudging object around.
10077 // Can push furniture out of reach.
10078 tripoint fpos = u.pos() + u.grab_point;
10079 // supposed position of grabbed furniture
10080 if( !m.has_furn( fpos ) ) {
10081 // Where did it go? We're grabbing thin air so reset.
10082 add_msg( m_info, _( "No furniture at grabbed point." ) );
10083 u.grab( OBJECT_NONE );
10084 return false;
10085 }
10086
10087 const bool pushing_furniture = dp == u.grab_point;
10088 const bool pulling_furniture = dp == -u.grab_point;
10089 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
10090
10091 tripoint fdest = fpos + dp; // intended destination of furniture.
10092 // Check floor: floorless tiles don't need to be flat and have no traps
10093 const bool has_floor = m.has_floor( fdest );
10094 // Unfortunately, game::is_empty fails for tiles we're standing on,
10095 // which will forbid pulling, so:
10096 const bool canmove = (
10097 m.passable( fdest ) &&
10098 critter_at<npc>( fdest ) == nullptr &&
10099 critter_at<monster>( fdest ) == nullptr &&
10100 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
10101 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
10102 !m.has_furn( fdest ) &&
10103 !m.veh_at( fdest ) &&
10104 ( !has_floor || m.tr_at( fdest ).is_null() )
10105 );
10106
10107 const furn_t furntype = m.furn( fpos ).obj();
10108 const int src_items = m.i_at( fpos ).size();
10109 const int dst_items = m.i_at( fdest ).size();
10110
10111 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
10112 [&]( item & liquid_item ) {
10113 return liquid_item.made_of( LIQUID );
10114 } );
10115
10116 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
10117 !m.has_flag( "SWIMMABLE", fdest ) &&
10118 !m.has_flag( "DESTROY_ITEM", fdest );
10119
10120 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
10121 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
10122 m.furn( fpos ).obj().has_flag( "SEALED" );
10123
10124 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
10125 time_duration fire_age = m.get_field_age( fpos, fd_fire );
10126
10127 int str_req = furntype.move_str_req;
10128 // Factor in weight of items contained in the furniture.
10129 units::mass furniture_contents_weight = 0_gram;
10130 for( auto &contained_item : m.i_at( fpos ) ) {
10131 furniture_contents_weight += contained_item.weight();
10132 }
10133 str_req += furniture_contents_weight / 4_kilogram;
10134 if( !canmove ) {
10135 // TODO: What is something?
10136 add_msg( _( "The %s collides with something." ), furntype.name() );
10137 u.moves -= 50;
10138 return true;
10139 ///\EFFECT_STR determines ability to drag furniture
10140 } else if( str_req > u.get_str() &&
10141 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
10142 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
10143 furntype.name() );
10144 u.moves -= 100;
10145 u.mod_pain( 1 ); // Hurt ourselves.
10146 return true; // furniture and or obstacle wins.
10147 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
10148 add_msg( _( "There's stuff in the way." ) );
10149 u.moves -= 50;
10150 return true;
10151 }
10152
10153 u.moves -= str_req * 10;
10154 // Additional penalty if we can't comfortably move it.
10155 if( str_req > u.get_str() ) {
10156 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
10157 if( move_penalty <= 1000 ) {
10158 if( u.get_str() >= str_req - 3 ) {
10159 u.moves -= std::max( 3000, move_penalty * 10 );
10160 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
10161 if( one_in( 3 ) ) {
10162 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
10163 return true;
10164 }
10165 } else {
10166 u.moves -= 100;
10167 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
10168 return true;
10169 }
10170 }
10171 u.moves -= move_penalty;
10172 if( move_penalty > 500 ) {
10173 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
10174 furntype.name() );
10175 } else if( move_penalty > 200 ) {
10176 if( one_in( 3 ) ) { // Nag only occasionally.
10177 add_msg( _( "It takes some time to move the heavy %s." ),
10178 furntype.name() );
10179 }
10180 }
10181 }
10183 _( "a scraping noise." ), true, "misc", "scraping" );
10184
10186 ( tripoint_abs_ms( m.getabs( fpos ) ) );
10187
10188 // Actually move the furniture.
10189 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
10190 m.furn_set( fpos, f_null );
10191
10192 if( fire_intensity == 1 && !pulling_furniture ) {
10193 m.remove_field( fpos, fd_fire );
10194 m.set_field_intensity( fdest, fd_fire, fire_intensity );
10195 m.set_field_age( fdest, fd_fire, fire_age );
10196 }
10197
10198 // Is there is only liquids on the ground, remove them after moving furniture.
10199 if( dst_items > 0 && only_liquid_items ) {
10200 m.i_clear( fdest );
10201 }
10202
10203 if( src_items > 0 ) { // Move the stuff inside.
10204 if( dst_item_ok && src_item_ok ) {
10205 // Assume contents of both cells are legal, so we can just swap contents.
10206 std::list<item> temp;
10207 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
10208 std::back_inserter( temp ) );
10209 m.i_clear( fpos );
10210 for( auto item_iter = m.i_at( fdest ).begin();
10211 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
10212 m.i_at( fpos ).insert( *item_iter );
10213 }
10214 m.i_clear( fdest );
10215 for( auto &cur_item : temp ) {
10216 m.i_at( fdest ).insert( cur_item );
10217 }
10218 } else {
10219 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
10220 }
10221 }
10222
10223 if( shifting_furniture ) {
10224 // We didn't move
10225 tripoint d_sum = u.grab_point + dp;
10226 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
10227 u.grab_point = d_sum; // furniture moved relative to us
10228 } else { // we pushed furniture out of reach
10229 add_msg( _( "You let go of the %s." ), furntype.name() );
10230 u.grab( OBJECT_NONE );
10231 }
10232 return true; // We moved furniture but stayed still.
10233 }
10234
10235 if( pushing_furniture && m.impassable( fpos ) ) {
10236 // Not sure how that chair got into a wall, but don't let player follow.
10237 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
10238 furntype.name(), m.tername( fdest ) );
10239 u.grab( OBJECT_NONE );
10240 return true;
10241 }
10242
10243 return false;
10244}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4076
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:639
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:5151
void insert(const item &newitem) override
Definition: map.cpp:153
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5443
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5317
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5351
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5357
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5330
std::string tername(const tripoint &p) const
Definition: map.cpp:1704
void i_clear(const tripoint &p)
Definition: map.cpp:4107
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1355
bool has_floor(const tripoint &p) const
Definition: map.cpp:2002
tripoint grab_point
Definition: player.h:683
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:505
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 10246 of file game.cpp.

10247{
10248 if( u.get_grab_type() == OBJECT_NONE ) {
10249 return false;
10250 }
10251
10252 if( dp.z != 0 ) {
10253 // No dragging stuff up/down stairs yet!
10254 return false;
10255 }
10256
10257 // vehicle: pulling, pushing, or moving around the grabbed object.
10258 if( u.get_grab_type() == OBJECT_VEHICLE ) {
10259 return grabbed_veh_move( dp );
10260 }
10261
10262 if( u.get_grab_type() == OBJECT_FURNITURE ) {
10263 return grabbed_furn_move( dp );
10264 }
10265
10266 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
10268 u.grab( OBJECT_NONE );
10269 return false;
10270}
object_type get_grab_type() const
Definition: avatar.cpp:647
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:10074
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150 grabbed_vehicle->adjust_zlevel( 1, dp );
151
152 // Grabbed part has to stay at distance 1 to the player
153 // and in roughly the same direction.
154 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
155 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
156 const tripoint expected_pos = u.pos() + dp + from;
157 const tripoint actual_dir = expected_pos - new_part_pos;
158
159 // Set player location to illegal value so it can't collide with vehicle.
160 const tripoint player_prev = u.pos();
162 std::vector<veh_collision> colls;
163 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
164 u.setpos( player_prev );
165 if( !colls.empty() ) {
166 blocker_name = colls.front().target_name;
167 }
168 return failed ? tripoint_zero : actual_dir;
169 };
170
171 // First try the move as intended
172 // But if that fails and the move is a zig-zag, try to recover:
173 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
174 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
175 if( final_dp_veh == tripoint_zero && zigzag ) {
176 final_dp_veh = get_move_dir( -prev_grab, -dp );
177 next_grab = -dp;
178 }
179
180 if( final_dp_veh == tripoint_zero ) {
181 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
182 u.grab_point = prev_grab;
183 return true;
184 }
185
186 u.grab_point = next_grab;
187
188 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
189
190 if( grabbed_vehicle ) {
191 grabbed_vehicle->shift_zlevel();
192 grabbed_vehicle->check_falling_or_floating();
193 } else {
194 debugmsg( "Grabbed vehicle disappeared" );
195 return false;
196 }
197
198 for( int p : wheel_indices ) {
199 if( one_in( 2 ) ) {
200 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
201 grabbed_vehicle->handle_trap( wheel_p, p );
202 }
203 }
204
205 return false;
206
207}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1114
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1775
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5649
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3104
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3026
bool valid_wheel_config() const
Definition: vehicle.cpp:4282
units::mass total_mass() const
Definition: vehicle.cpp:3129
std::vector< int > wheelcache
Definition: vehicle.h:1798
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1928
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6791
int part_count() const
Definition: vehicle.cpp:6898
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3085
vehicle_part & part(int part_num)
Definition: vehicle.cpp:6903
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3109
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1907
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1512 of file handle_action.cpp.

1513{
1514 std::string action;
1515 input_context ctxt;
1517 user_turn current_turn;
1518 // Check if we have an auto-move destination
1519 if( u.has_destination() ) {
1521 if( act == ACTION_NULL ) {
1522 add_msg( m_info, _( "Auto-move canceled" ) );
1524 return false;
1525 }
1526 } else if( u.has_destination_activity() ) {
1527 // starts destination activity after the player successfully reached his destination
1529 return false;
1530 } else {
1531 // No auto-move, ask player for input
1532 ctxt = get_player_input( action );
1533 }
1534
1535 const optional_vpart_position vp = m.veh_at( u.pos() );
1536 bool veh_ctrl = !u.is_dead_state() &&
1537 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1538
1539 // If performing an action with right mouse button, co-ordinates
1540 // of location clicked.
1541 cata::optional<tripoint> mouse_target;
1542
1543 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1544 uquit = QUIT_DIED;
1545 return false;
1546 }
1547
1548 if( act == ACTION_NULL ) {
1550
1551 if( act == ACTION_KEYBINDINGS ) {
1552 // already handled by input context
1553 return false;
1554 }
1555
1556 if( act == ACTION_MAIN_MENU ) {
1557 if( uquit == QUIT_WATCH ) {
1558 return false;
1559 }
1560 // No auto-move actions have or can be set at this point.
1562 destination_preview.clear();
1564 if( act == ACTION_NULL ) {
1565 return false;
1566 }
1567 }
1568
1569 if( act == ACTION_ACTIONMENU ) {
1570 if( uquit == QUIT_WATCH ) {
1571 return false;
1572 }
1573 // No auto-move actions have or can be set at this point.
1575 destination_preview.clear();
1577 if( act == ACTION_NULL ) {
1578 return false;
1579 }
1580#if defined(__ANDROID__)
1581 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1582 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1583 }
1584#endif
1585 }
1586
1587 if( act == ACTION_KEYBINDINGS ) {
1589 destination_preview.clear();
1590 act = ctxt.display_menu( true );
1591 if( act == ACTION_NULL ) {
1592 return false;
1593 }
1594 }
1595
1598 }
1599
1600 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1601 // Mouse button click
1602 if( veh_ctrl ) {
1603 // No mouse use in vehicle
1604 return false;
1605 }
1606
1607 if( u.is_dead_state() ) {
1608 // do not allow mouse actions while dead
1609 return false;
1610 }
1611
1612 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1613 if( !mouse_pos ) {
1614 return false;
1615 } else if( !u.sees( *mouse_pos ) ) {
1616 // Not clicked in visible terrain
1617 return false;
1618 }
1619 mouse_target = mouse_pos;
1620
1621 if( act == ACTION_SELECT ) {
1622 // Note: The following has the potential side effect of
1623 // setting auto-move destination state in addition to setting
1624 // act.
1625 if( !try_get_left_click_action( act, *mouse_target ) ) {
1626 return false;
1627 }
1628 } else if( act == ACTION_SEC_SELECT ) {
1629 if( !try_get_right_click_action( act, *mouse_target ) ) {
1630 return false;
1631 }
1632 }
1633 } else if( act != ACTION_TIMEOUT ) {
1634 // act has not been set for an auto-move, so clearing possible
1635 // auto-move destinations. Since initializing an auto-move with
1636 // the mouse may span across multiple actions, we do not clear the
1637 // auto-move destination if the action is only a timeout, as this
1638 // would require the user to double click quicker than the
1639 // timeout delay.
1641 destination_preview.clear();
1642 }
1643 }
1644
1645 if( act == ACTION_NULL ) {
1646 const input_event &&evt = ctxt.get_raw_input();
1647 if( !evt.sequence.empty() ) {
1648 const int ch = evt.get_first_input();
1649 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1650 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1651 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1652 if( const cata::optional<std::string> hint =
1654 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1655 "the current context." ),
1656 *hint );
1657 }
1658 }
1659 }
1660 return false;
1661 }
1662
1663 // This has no action unless we're in a special game mode.
1664 gamemode->pre_action( act );
1665
1666 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1667
1668 int before_action_moves = u.moves;
1669
1670 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1671 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1672 switch( act ) {
1675 break;
1676
1677 case ACTION_CENTER:
1680 break;
1681
1682 case ACTION_SHIFT_N:
1683 case ACTION_SHIFT_NE:
1684 case ACTION_SHIFT_E:
1685 case ACTION_SHIFT_SE:
1686 case ACTION_SHIFT_S:
1687 case ACTION_SHIFT_SW:
1688 case ACTION_SHIFT_W:
1689 case ACTION_SHIFT_NW: {
1690 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1699 };
1701 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1702 }
1703 break;
1704
1705 case ACTION_LOOK:
1706 look_around();
1707 break;
1708
1709 case ACTION_KEYBINDINGS:
1710 // already handled by input context
1711 break;
1712
1713 default:
1714 break;
1715 }
1716 }
1717
1718 // actions allowed only while alive
1719 if( !u.is_dead_state() ) {
1720 switch( act ) {
1721 case ACTION_NULL:
1722 case NUM_ACTIONS:
1723 break; // dummy entries
1724 case ACTION_ACTIONMENU:
1725 case ACTION_MAIN_MENU:
1726 case ACTION_KEYBINDINGS:
1727 break; // handled above
1728
1729 case ACTION_TIMEOUT:
1730 if( check_safe_mode_allowed( false ) ) {
1731 u.pause();
1732 }
1733 break;
1734
1735 case ACTION_PAUSE:
1736 if( check_safe_mode_allowed() ) {
1737 u.pause();
1738 }
1739 break;
1740
1741 case ACTION_CYCLE_MOVE:
1743 break;
1744
1745 case ACTION_RESET_MOVE:
1747 break;
1748
1749 case ACTION_TOGGLE_RUN:
1751 break;
1752
1755 break;
1756
1759 break;
1760
1761 case ACTION_MOVE_FORTH:
1763 case ACTION_MOVE_RIGHT:
1765 case ACTION_MOVE_BACK:
1767 case ACTION_MOVE_LEFT:
1769 if( !u.get_value( "remote_controlling" ).empty() &&
1773 } else if( veh_ctrl ) {
1774 // vehicle control uses x for steering and y for ac/deceleration,
1775 // so no rotation needed
1777 } else {
1779 if( auto_travel_mode && !u.is_auto_moving() ) {
1780 for( int i = 0; i < SEEX; i++ ) {
1781 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1782 u.posy() + dest_delta.y * ( SEEX - i ),
1783 u.posz() );
1785 auto_travel_destination,
1787 u.get_path_avoid() );
1788 if( !destination_preview.empty() ) {
1791 break;
1792 }
1793 }
1796 if( dest_next == point_zero ) {
1798 }
1799 dest_delta = dest_next;
1800 }
1801 if( !avatar_action::move( u, m, dest_delta ) ) {
1802 // auto-move should be canceled due to a failed move or obstacle
1804 }
1805 }
1806 break;
1807 case ACTION_MOVE_DOWN:
1808 if( u.is_mounted() ) {
1809 auto mon = u.mounted_creature.get();
1810 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1811 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1812 break;
1813 }
1814 }
1815 if( !u.in_vehicle ) {
1816 vertical_move( -1, false );
1817 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1819 }
1820 break;
1821
1822 case ACTION_MOVE_UP:
1823 if( u.is_mounted() ) {
1824 auto mon = u.mounted_creature.get();
1825 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1826 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1827 break;
1828 }
1829 }
1830 if( !u.in_vehicle ) {
1831 vertical_move( 1, false );
1832 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1834 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1835 !vp->vehicle().has_sufficient_rotorlift() ) {
1836 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1837 }
1838 break;
1839
1840 case ACTION_OPEN:
1842 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1843 } else if( u.is_mounted() ) {
1844 add_msg( m_info, _( "You can't open things while you're riding." ) );
1845 } else {
1846 open();
1847 }
1848 break;
1849
1850 case ACTION_CLOSE:
1852 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1853 } else if( u.is_mounted() ) {
1854 auto mon = u.mounted_creature.get();
1855 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1856 add_msg( m_info, _( "You can't close things while you're riding." ) );
1857 }
1858 } else if( mouse_target ) {
1859 doors::close_door( m, u, *mouse_target );
1860 } else {
1861 close();
1862 }
1863 break;
1864
1865 case ACTION_SMASH:
1866 if( veh_ctrl ) {
1867 handbrake();
1868 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1869 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1870 } else {
1871 smash();
1872 }
1873 break;
1874
1875 case ACTION_EXAMINE:
1877 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1878 } else if( mouse_target ) {
1879 examine( *mouse_target );
1880 } else {
1881 examine();
1882 }
1883 break;
1884
1885 case ACTION_ADVANCEDINV:
1887 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1888 } else if( u.is_mounted() ) {
1889 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1890 } else {
1892 }
1893 break;
1894
1895 case ACTION_PICKUP:
1897 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1898 } else if( u.is_mounted() ) {
1899 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1900 } else if( mouse_target ) {
1901 pickup( *mouse_target );
1902 } else {
1903 pickup();
1904 }
1905 break;
1906
1907 case ACTION_PICKUP_FEET:
1909 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1910 } else {
1911 pickup_feet();
1912 }
1913 break;
1914
1915 case ACTION_GRAB:
1917 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1918 } else if( u.is_mounted() ) {
1919 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1920 } else {
1921 grab();
1922 }
1923 break;
1924
1925 case ACTION_HAUL:
1927 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1928 } else if( u.is_mounted() ) {
1929 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1930 } else {
1931 haul();
1932 }
1933 break;
1934
1935 case ACTION_BUTCHER:
1937 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1938 } else if( u.is_mounted() ) {
1939 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1940 } else {
1941 butcher();
1942 }
1943 break;
1944
1945 case ACTION_CHAT:
1946 chat();
1947 break;
1948
1949 case ACTION_PEEK:
1951 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1952 } else if( u.is_mounted() ) {
1953 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1954 } else {
1955 peek();
1956 }
1957 break;
1958
1959 case ACTION_LIST_ITEMS:
1961 break;
1962
1963 case ACTION_ZONES:
1964 zones_manager();
1965 break;
1966
1967 case ACTION_LOOT:
1968 loot();
1969 break;
1970
1971 case ACTION_INVENTORY:
1973 break;
1974
1975 case ACTION_COMPARE:
1977 break;
1978
1979 case ACTION_ORGANIZE:
1981 break;
1982
1983 case ACTION_USE:
1984 // Shell-users are presumed to be able to mess with their inventories, etc
1985 // while in the shell. Eating, gear-changing, and item use are OK.
1987 break;
1988
1989 case ACTION_USE_WIELDED:
1990 u.use_wielded();
1991 break;
1992
1993 case ACTION_WEAR:
1994 wear();
1995 break;
1996
1997 case ACTION_TAKE_OFF:
1998 takeoff();
1999 break;
2000
2001 case ACTION_EAT:
2002 if( !avatar_action::eat_here( u ) ) {
2004 }
2005 break;
2006
2008 if( !avatar_action::eat_here( u ) ) {
2010 }
2011 break;
2012
2013 case ACTION_READ:
2014 // Shell-users are presumed to have the book just at an opening and read it that way
2015 read();
2016 break;
2017
2018 case ACTION_WIELD:
2019 wield();
2020 break;
2021
2022 case ACTION_PICK_STYLE:
2023 u.martial_arts_data->pick_style( u );
2024 break;
2025
2026 case ACTION_RELOAD_ITEM:
2027 reload_item();
2028 break;
2029
2031 reload_weapon();
2032 break;
2033
2036 break;
2037
2038 case ACTION_UNLOAD:
2040 break;
2041
2042 case ACTION_MEND:
2044 break;
2045
2046 case ACTION_THROW: {
2047 item_location loc;
2048 avatar_action::plthrow( g->u, loc );
2049 break;
2050 }
2051
2052 case ACTION_FIRE:
2053 fire();
2054 break;
2055
2056 case ACTION_CAST_SPELL:
2057 cast_spell();
2058 break;
2059
2060 case ACTION_FIRE_BURST: {
2061 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2063 }
2064 break;
2065 }
2066
2068 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2069 if( u.weapon.gun_all_modes().size() > 1 ) {
2071 } else {
2072 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2073 }
2074 }
2075 break;
2076
2078 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2080 }
2081 break;
2082
2083 case ACTION_DROP:
2084 // You CAN drop things to your own tile while in the shell.
2085 drop();
2086 break;
2087
2088 case ACTION_DIR_DROP:
2090 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2091 } else {
2093 }
2094 break;
2095 case ACTION_BIONICS:
2096 u.power_bionics();
2097 break;
2098 case ACTION_MUTATIONS:
2100 break;
2101
2102 case ACTION_SORT_ARMOR:
2103 u.sort_armor();
2104 break;
2105
2106 case ACTION_WAIT:
2107 wait();
2108 break;
2109
2110 case ACTION_CRAFT:
2112 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2113 } else if( u.is_mounted() ) {
2114 add_msg( m_info, _( "You can't craft while you're riding." ) );
2115 } else {
2116 u.craft();
2117 }
2118 break;
2119
2120 case ACTION_RECRAFT:
2122 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2123 } else if( u.is_mounted() ) {
2124 add_msg( m_info, _( "You can't craft while you're riding." ) );
2125 } else {
2126 u.recraft();
2127 }
2128 break;
2129
2130 case ACTION_LONGCRAFT:
2132 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2133 } else if( u.is_mounted() ) {
2134 add_msg( m_info, _( "You can't craft while you're riding." ) );
2135 } else {
2136 u.long_craft();
2137 }
2138 break;
2139
2140 case ACTION_DISASSEMBLE:
2141 if( u.controlling_vehicle ) {
2142 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2143 } else if( u.is_mounted() ) {
2144 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2145 } else {
2146 u.disassemble();
2147 }
2148 break;
2149
2150 case ACTION_CONSTRUCT:
2151 if( u.in_vehicle ) {
2152 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2153 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2154 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2155 } else if( u.is_mounted() ) {
2156 add_msg( m_info, _( "You can't construct while you're riding." ) );
2157 } else {
2158 construction_menu( false );
2159 }
2160 break;
2161
2162 case ACTION_SLEEP:
2163 if( veh_ctrl ) {
2164 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2165 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2166 _( "new default binding is '^'." ) ) );
2167 } else {
2168 sleep();
2169 }
2170 break;
2171
2174 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2175 } else if( u.is_mounted() ) {
2176 u.dismount();
2177 } else {
2179 }
2180 break;
2181
2184 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2185 break;
2186
2188 if( safe_mode == SAFE_MODE_OFF ) {
2190 mostseen = 0;
2191 add_msg( m_info, _( "Safe mode ON!" ) );
2192 } else {
2195 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2196 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2197 }
2201 }
2202 break;
2203
2205 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2206 add_msg( m_info, autosafemode_option.value_as<bool>()
2207 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2208 autosafemode_option.setNext();
2209 break;
2210 }
2211
2213 if( safe_mode == SAFE_MODE_STOP ) {
2214 add_msg( m_info, _( "Ignoring enemy!" ) );
2215 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2216 monster &critter = *elem;
2217 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2218 }
2220 } else if( u.has_effect( effect_laserlocked ) ) {
2221 if( u.has_trait( trait_PROF_CHURL ) ) {
2222 add_msg( m_warning, _( "You make the sign of the cross." ) );
2223 } else {
2224 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2225 }
2228 }
2229 break;
2230
2232 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2234 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2236 mostseen = 0;
2237 } else {
2238 get_safemode().show();
2239 }
2240 break;
2241
2242 case ACTION_SUICIDE:
2243 if( query_yn( _( "Commit suicide?" ) ) ) {
2244 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2245 u.moves = 0;
2246 u.place_corpse();
2248 }
2249 }
2250 break;
2251
2252 case ACTION_SAVE:
2253 if( query_yn( _( "Save and quit?" ) ) ) {
2254 if( save() ) {
2255 u.moves = 0;
2256 uquit = QUIT_SAVED;
2257 }
2258 }
2259 break;
2260
2261 case ACTION_QUICKSAVE:
2262 quicksave();
2263 return false;
2264
2265 case ACTION_QUICKLOAD:
2266 quickload();
2267 return false;
2268
2269 case ACTION_PL_INFO:
2270 u.disp_info();
2271 break;
2272
2273 case ACTION_MAP:
2275 break;
2276
2277 case ACTION_SKY:
2278 if( m.is_outside( u.pos() ) ) {
2280 } else {
2281 add_msg( m_info, _( "You can't see the sky from here." ) );
2282 }
2283 break;
2284
2285 case ACTION_MISSIONS:
2286 list_missions();
2287 break;
2288
2289 case ACTION_SCORES:
2291 break;
2292
2293 case ACTION_FACTIONS:
2294 faction_manager_ptr->display();
2295 break;
2296
2297 case ACTION_MORALE:
2298 u.disp_morale();
2299 break;
2300
2301 case ACTION_MESSAGES:
2303 break;
2304
2305 case ACTION_HELP:
2307 break;
2308
2309 case ACTION_OPTIONS:
2310 get_options().show( true );
2311 break;
2312
2313 case ACTION_AUTOPICKUP:
2315 break;
2316
2317 case ACTION_AUTONOTES:
2319 break;
2320
2321 case ACTION_SAFEMODE:
2322 get_safemode().show();
2323 break;
2324
2325 case ACTION_COLOR:
2326 all_colors.show_gui();
2327 break;
2328
2329 case ACTION_WORLD_MODS:
2330 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2331 break;
2332
2333 case ACTION_DEBUG:
2335 break; //don't do anything when sharing and not debugger
2336 }
2338 break;
2339
2342 break;
2343
2346 break;
2347
2350 break;
2351
2354 break;
2355
2357 get_options().get_option( "AUTO_FEATURES" ).setNext();
2358 get_options().save();
2359 //~ Auto Features are now ON/OFF
2360 add_msg( _( "%s are now %s." ),
2361 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2362 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2363 break;
2364
2366 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2367 get_options().save();
2368 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2369 add_msg( _( "%s is now set to %s." ),
2370 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2371 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2372 break;
2373
2375 get_options().get_option( "AUTO_MINING" ).setNext();
2376 get_options().save();
2377 //~ Auto Mining is now ON/OFF
2378 add_msg( _( "%s is now %s." ),
2379 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2380 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2381 break;
2382
2384 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2385 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2386 u.set_value( "THIEF_MODE_KEEP", "YES" );
2387 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2388 add_msg( _( "You will not pick up other peoples belongings." ) );
2389 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2390 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2391 u.set_value( "THIEF_MODE_KEEP", "YES" );
2392 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2393 add_msg( _( "You will pick up also those things that belong to others!" ) );
2394 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2395 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2396 u.set_value( "THIEF_MODE_KEEP", "NO" );
2397 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2398 add_msg( _( "You will be reminded not to steal." ) );
2399 } else {
2400 // ERROR
2401 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2402 }
2403 break;
2404
2406 get_options().get_option( "AUTO_FORAGING" ).setNext();
2407 get_options().save();
2408 //~ Auto Foraging is now set to x
2409 add_msg( _( "%s is now set to %s." ),
2410 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2411 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2412 break;
2413
2415 get_options().get_option( "AUTO_PICKUP" ).setNext();
2416 get_options().save();
2417 //~ Auto pickup is now set to x
2418 add_msg( _( "%s is now set to %s." ),
2419 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2420 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2421 break;
2422
2425 break; //don't do anything when sharing and not debugger
2426 }
2427 display_scent();
2428 break;
2429
2432 break; //don't do anything when sharing and not debugger
2433 }
2434 display_scent();
2435 break;
2436
2439 break; //don't do anything when sharing and not debugger
2440 }
2442 break;
2445 break; //don't do anything when sharing and not debugger
2446 }
2448 break;
2451 break; //don't do anything when sharing and not debugger
2452 }
2454 break;
2455
2458 break; //don't do anything when sharing and not debugger
2459 }
2461 break;
2462
2465 break; //don't do anything when sharing and not debugger
2466 }
2468 break;
2469
2472 break; //don't do anything when sharing and not debugger
2473 }
2475 break;
2476
2478 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2479 break;
2480
2483 break;
2484
2487 break; //don't do anything when sharing and not debugger
2488 }
2490 if( debug_mode ) {
2491 add_msg( m_info, _( "Debug mode ON!" ) );
2492 } else {
2493 add_msg( m_info, _( "Debug mode OFF!" ) );
2494 }
2495 break;
2496
2497 case ACTION_ZOOM_IN:
2498 zoom_in();
2500 break;
2501
2502 case ACTION_ZOOM_OUT:
2503 zoom_out();
2505 break;
2506
2507 case ACTION_ITEMACTION:
2509 break;
2510
2511 case ACTION_AUTOATTACK:
2513 break;
2514
2515 default:
2516 break;
2517 }
2518 }
2519 if( act != ACTION_TIMEOUT ) {
2520 u.mod_moves( -current_turn.moves_elapsed() );
2521 }
2522 gamemode->post_action( act );
2523
2524 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2525 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2526 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2527 return ( !u.is_dead_state() );
2528}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:468
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:347
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:417
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:935
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:506
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:653
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:265
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:259
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:263
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:267
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:261
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:269
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1591
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2559
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9956
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9970
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1242
item weapon
Definition: character.h:1587
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1328
std::string get_value(const std::string &key) const
Definition: creature.cpp:1338
void mod_moves(int nmoves)
Definition: creature.cpp:1405
void cycle_move_mode()
Definition: avatar.cpp:1198
void toggle_map_memory()
Definition: avatar.cpp:117
void toggle_crouch_mode()
Definition: avatar.cpp:1182
void toggle_run_mode()
Definition: avatar.cpp:1173
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:985
void reset_move_mode()
Definition: avatar.cpp:1191
void item_action_menu()
void display_radiation()
Definition: game.cpp:11780
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2616
void wield()
Definition: game.cpp:9109
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:9182
void reload_wielded(bool prompt=false)
Definition: game.cpp:8942
cata::optional< tripoint > look_around()
Definition: game.cpp:6850
void pickup_feet()
Definition: game.cpp:5907
void zones_manager()
Definition: game.cpp:6375
int turnssincelastmon
Definition: game.h:1069
void display_visibility()
Definition: game.cpp:11694
void display_scent()
Definition: game.cpp:11659
bool save()
Returns false if saving failed.
Definition: game.cpp:3109
void butcher()
Definition: game.cpp:8569
void display_temperature()
Definition: game.cpp:11680
bool auto_travel_mode
Definition: game.h:1066
void zoom_out()
Definition: game.cpp:7317
void toggle_pixel_minimap()
Definition: game.cpp:508
void toggle_debug_hour_timer()
Definition: game.cpp:11726
void display_transparency()
Definition: game.cpp:11787
void list_items_monsters()
Definition: game.cpp:7494
void chat()
Definition: npctalk.cpp:393
void quickload()
Definition: game.cpp:11822
void pickup()
Definition: game.cpp:5885
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10507
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11754
void control_vehicle()
Definition: game.cpp:5455
void peek()
Definition: game.cpp:5914
void drop()
Definition: game.cpp:8308
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2644
void reload_weapon(bool try_everything=true)
Definition: game.cpp:8952
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:9120
void zoom_in()
Definition: game.cpp:7329
void toggle_fullscreen()
Definition: game.cpp:498
void display_vehicle_ai()
Definition: game.cpp:11687
void reload_item()
Definition: game.cpp:8928
void reload_tileset()
Definition: game.cpp:519
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3357
void drop_in_direction()
Definition: game.cpp:8313
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6356
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7747
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4695
bool is_gunmod() const
Definition: item.cpp:6386
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7666
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7738
bool is_outside(const tripoint &p) const
Definition: map.cpp:2558
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:255
short ignoring
Definition: monster.h:505
cOpt & get_option(const std::string &name)
Definition: options.cpp:3334
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2722
void show_adm()
Definition: panels.cpp:2405
void pause()
Definition: player.cpp:756
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:335
void disp_info()
Handles and displays detailed character info for the '@' screen.
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3229
int movecounter
Definition: player.h:696
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:346
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:355
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
construction_id construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void mend(avatar &you, item_location loc)
void unload(avatar &you)
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3742
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, auto_travel_mode, avatar_action::autoattack(), bio_remote, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, player::disassemble(), Character::dismount(), player::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), reload_item(), reload_tileset(), reload_weapon(), reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2055 of file game.cpp.

2056{
2058 const std::string action = ctxt.handle_input( 0 );
2059 bool refresh = true;
2060 if( action == "pause" ) {
2062 cancel_activity_query( _( "Confirm:" ) );
2063 }
2064 } else if( action == "player_data" ) {
2065 u.disp_info();
2066 } else if( action == "messages" ) {
2068 } else if( action == "help" ) {
2070 } else if( action != "HELP_KEYBINDINGS" ) {
2071 refresh = false;
2072 }
2073 if( refresh ) {
2076 }
2077}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1839
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), player::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2323 of file game.cpp.

2324{
2325 cata::optional<tripoint> liveview_pos;
2326
2327 do {
2328 action = ctxt.handle_input();
2329 if( action == "MOUSE_MOVE" ) {
2330 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2331 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2332 liveview_pos = mouse_pos;
2333 liveview.show( *liveview_pos );
2334 } else if( !mouse_pos ) {
2335 liveview_pos.reset();
2336 liveview.hide();
2337 }
2339 }
2340 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2341
2342 if( action != "TIMEOUT" ) {
2343 // Keyboard event, break out of animation loop
2344 liveview.hide();
2345 return false;
2346 }
2347
2348 // Mouse movement or un-handled key
2349 return true;
2350}
void reset() noexcept
Definition: optional.h:155
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 622 of file game.cpp.

623{
624 return gamemode && gamemode->id() != SGAME_NULL;
625}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11794 of file game.cpp.

11795{
11797 last_save_timestamp = time( nullptr );
11798}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 390 of file game_inventory.cpp.

392{
394 title, radius, none_message );
395}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:330

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

Referenced by reload_item().

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ inventory_item_menu()

int game::inventory_item_menu ( item_location  locThisItem,
const std::function< int()> &  startx = []() { return 0; },
const std::function< int()> &  width = []() { return 50; },
inventory_item_menu_positon  position = RIGHT_OF_INFO 
)

Definition at line 2087 of file game.cpp.

2091{
2092 int cMenu = static_cast<int>( '+' );
2093
2094 item &oThisItem = *locThisItem;
2095 if( u.has_item( oThisItem ) ) {
2096#if defined(__ANDROID__)
2097 if( get_option<bool>( "ANDROID_INVENTORY_AUTOADD" ) ) {
2098 add_key_to_quick_shortcuts( oThisItem.invlet, "INVENTORY", false );
2099 }
2100#endif
2101
2102 std::vector<iteminfo> vThisItem;
2103 std::vector<iteminfo> vDummy;
2104
2105 const bool bHPR = get_auto_pickup().has_rule( &oThisItem );
2106 const bool is_wielded = u.is_wielding( oThisItem );
2107 const bool cant_unwield_if_weapon = is_wielded && !u.can_unwield( oThisItem ).success();
2108 const bool cant_unwield_existing_weapon = u.is_armed() && !u.can_unwield( u.weapon ).success();
2109 const bool cant_takeoff_if_worn = u.is_wearing( oThisItem ) &&
2110 !u.can_takeoff( oThisItem ).success();
2111 const bool cant_dispose_of = cant_unwield_if_weapon || cant_takeoff_if_worn;
2112 const bool cant_acquare = cant_unwield_existing_weapon || cant_takeoff_if_worn;
2113 const hint_rating rate_unwield_item = cant_dispose_of ? hint_rating::cant :
2115 const hint_rating rate_wield_item = cant_acquare ? hint_rating::cant :
2117 const hint_rating rate_drop_item = cant_dispose_of ? hint_rating::cant :
2119
2120 uilist action_menu;
2121 action_menu.allow_anykey = true;
2122 const auto addentry = [&]( const char key, const std::string & text, const hint_rating hint ) {
2123 // The char is used as retval from the uilist *and* as hotkey.
2124 action_menu.addentry( key, true, key, text );
2125 auto &entry = action_menu.entries.back();
2126 switch( hint ) {
2127 case hint_rating::cant:
2128 entry.text_color = c_light_gray;
2129 break;
2130 case hint_rating::iffy:
2131 entry.text_color = c_light_red;
2132 break;
2133 case hint_rating::good:
2134 entry.text_color = c_light_green;
2135 break;
2136 }
2137 };
2138 addentry( 'a', pgettext( "action", "activate" ), u.rate_action_use( oThisItem ) );
2139 addentry( 'R', pgettext( "action", "read" ), u.rate_action_read( oThisItem ) );
2140 addentry( 'E', pgettext( "action", "eat" ), u.rate_action_eat( oThisItem ) );
2141 addentry( 'W', pgettext( "action", "wear" ), u.rate_action_wear( oThisItem ) );
2142 if( is_wielded ) {
2143 addentry( 'w', pgettext( "action", "unwield" ), rate_unwield_item );
2144 } else {
2145 addentry( 'w', pgettext( "action", "wield" ), rate_wield_item );
2146 }
2147 addentry( 't', pgettext( "action", "throw" ), rate_drop_item );
2148 addentry( 'c', pgettext( "action", "change side" ), u.rate_action_change_side( oThisItem ) );
2149 addentry( 'T', pgettext( "action", "take off" ), u.rate_action_takeoff( oThisItem ) );
2150 addentry( 'd', pgettext( "action", "drop" ), rate_drop_item );
2151 addentry( 'U', pgettext( "action", "unload" ), u.rate_action_unload( oThisItem ) );
2152 addentry( 'r', pgettext( "action", "reload" ), u.rate_action_reload( oThisItem ) );
2153 addentry( 'p', pgettext( "action", "part reload" ), u.rate_action_reload( oThisItem ) );
2154 addentry( 'm', pgettext( "action", "mend" ), u.rate_action_mend( oThisItem ) );
2155 addentry( 'D', pgettext( "action", "disassemble" ), u.rate_action_disassemble( oThisItem ) );
2156
2157 if( oThisItem.is_favorite ) {
2158 addentry( 'f', pgettext( "action", "unfavorite" ), hint_rating::good );
2159 } else {
2160 addentry( 'f', pgettext( "action", "favorite" ), hint_rating::good );
2161 }
2162
2163 addentry( '=', pgettext( "action", "reassign" ), hint_rating::good );
2164
2165 if( bHPR ) {
2166 addentry( '-', _( "Autopickup" ), hint_rating::iffy );
2167 } else {
2168 addentry( '+', _( "Autopickup" ), hint_rating::good );
2169 }
2170
2171 int iScrollPos = 0;
2172 oThisItem.info( true, vThisItem );
2173
2174 action_menu.w_y_setup = 0;
2175 action_menu.w_x_setup = [&]( const int popup_width ) -> int {
2176 switch( position )
2177 {
2178 default:
2180 return 0;
2181 case LEFT_OF_INFO:
2182 return iStartX() - popup_width;
2183 case RIGHT_OF_INFO:
2184 return iStartX() + iWidth();
2185 case LEFT_TERMINAL_EDGE:
2186 return TERMX - popup_width;
2187 }
2188 };
2189 // Filtering isn't needed, the number of entries is manageable.
2190 action_menu.filtering = false;
2191 // Default menu border color is different, this matches the border of the item info window.
2192 action_menu.border_color = BORDER_COLOR;
2193
2194 item_info_data data( oThisItem.tname(), oThisItem.type_name(), vThisItem, vDummy, iScrollPos );
2195 data.without_getch = true;
2196
2197 catacurses::window w_info;
2198 int iScrollHeight = 0;
2199
2200 std::unique_ptr<ui_adaptor> ui = std::make_unique<ui_adaptor>();
2201 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
2202 w_info = catacurses::newwin( TERMY, iWidth(), point( iStartX(), 0 ) );
2203 iScrollHeight = TERMY - 2;
2204 ui.position_from_window( w_info );
2205 } );
2206 ui->mark_resize();
2207
2208 ui->on_redraw( [&]( const ui_adaptor & ) {
2209 draw_item_info( w_info, data );
2210 } );
2211
2212 bool exit = false;
2213 do {
2214 const int prev_selected = action_menu.selected;
2215 action_menu.query( false );
2216 if( action_menu.ret >= 0 ) {
2217 cMenu = action_menu.ret; /* Remember: hotkey == retval, see addentry above. */
2218 } else if( action_menu.ret == UILIST_UNBOUND && action_menu.keypress == KEY_RIGHT ) {
2219 // Simulate KEY_RIGHT == '\n' (confirm currently selected entry) for compatibility with old version.
2220 // TODO: ideally this should be done in the uilist, maybe via a callback.
2221 cMenu = action_menu.ret = action_menu.entries[action_menu.selected].retval;
2222 } else if( action_menu.keypress == KEY_PPAGE || action_menu.keypress == KEY_NPAGE ) {
2223 cMenu = action_menu.keypress;
2224 // Prevent the menu from scrolling with this key. TODO: Ideally the menu
2225 // could be instructed to ignore these two keys instead of scrolling.
2226 action_menu.selected = prev_selected;
2227 action_menu.fselected = prev_selected;
2228 action_menu.vshift = 0;
2229 } else {
2230 cMenu = 0;
2231 }
2232
2233 if( action_menu.ret != UILIST_WAIT_INPUT && action_menu.ret != UILIST_UNBOUND ) {
2234 exit = true;
2235 ui = nullptr;
2236 }
2237
2238 switch( cMenu ) {
2239 case 'a':
2240 avatar_action::use_item( u, locThisItem );
2241 break;
2242 case 'E':
2243 avatar_action::eat( u, locThisItem );
2244 break;
2245 case 'W':
2246 u.wear( oThisItem );
2247 break;
2248 case 'w':
2249 wield( locThisItem );
2250 break;
2251 case 't':
2252 avatar_action::plthrow( u, locThisItem );
2253 break;
2254 case 'c':
2255 u.change_side( locThisItem );
2256 break;
2257 case 'T':
2258 u.takeoff( oThisItem );
2259 break;
2260 case 'd':
2261 u.drop( locThisItem, u.pos() );
2262 break;
2263 case 'U':
2264 unload( locThisItem );
2265 break;
2266 case 'r':
2267 reload( locThisItem );
2268 break;
2269 case 'p':
2270 reload( locThisItem, true );
2271 break;
2272 case 'm':
2273 avatar_action::mend( u, locThisItem );
2274 break;
2275 case 'R':
2276 u.read( locThisItem );
2277 break;
2278 case 'D':
2279 u.disassemble( locThisItem, false );
2280 break;
2281 case 'f':
2282 oThisItem.is_favorite = !oThisItem.is_favorite;
2283 break;
2284 case '=':
2285 game_menus::inv::reassign_letter( u, oThisItem );
2286 break;
2287 case KEY_PPAGE:
2288 iScrollPos -= iScrollHeight;
2289 if( ui ) {
2290 ui->invalidate_ui();
2291 }
2292 break;
2293 case KEY_NPAGE:
2294 iScrollPos += iScrollHeight;
2295 if( ui ) {
2296 ui->invalidate_ui();
2297 }
2298 break;
2299 case '+':
2300 if( !bHPR ) {
2301 get_auto_pickup().add_rule( &oThisItem );
2302 add_msg( m_info, _( "'%s' added to character pickup rules." ), oThisItem.tname( 1,
2303 false ) );
2304 }
2305 break;
2306 case '-':
2307 if( bHPR ) {
2308 get_auto_pickup().remove_rule( &oThisItem );
2309 add_msg( m_info, _( "'%s' removed from character pickup rules." ), oThisItem.tname( 1,
2310 false ) );
2311 }
2312 break;
2313 default:
2314 break;
2315 }
2316 } while( !exit );
2317 }
2318 return cMenu;
2319}
hint_rating rate_action_change_side(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: character.cpp:3693
bool is_wielding(const item &target) const
Definition: character.cpp:3233
bool change_side(item &it, bool interactive=true)
Swap side on which item is worn; returns false on fail.
Definition: character.cpp:3706
ret_val< bool > can_unwield(const item &it) const
Check player capable of unwielding an item.
Definition: character.cpp:3153
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3238
hint_rating rate_action_eat(const item &it) const
void remove_rule(const item *it)
bool has_rule(const item *it)
void add_rule(const item *it)
hint_rating rate_action_read(const item &it) const
Definition: avatar.cpp:933
bool read(item_location loc, bool continuous=false)
Handles reading effects and returns true if activity started.
Definition: avatar.cpp:367
bool unload(item_location loc)
Definition: game.cpp:9016
void reload(item_location &loc, bool prompt=false, bool empty=true)
Definition: game.cpp:8844
bool is_favorite
Definition: item.h:2234
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1100
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9667
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4433
char invlet
Definition: item.h:2232
hint_rating rate_action_mend(const item &it) const
Definition: player.cpp:3296
cata::optional< std::list< item >::iterator > wear(int pos, bool interactive=true)
Wear item; returns false on fail.
Definition: player.cpp:2873
hint_rating rate_action_takeoff(const item &it) const
Definition: player.cpp:2923
hint_rating rate_action_reload(const item &it) const
Definition: player.cpp:3234
hint_rating rate_action_wear(const item &it) const
Definition: player.cpp:2638
hint_rating rate_action_disassemble(const item &it)
Definition: player.cpp:3305
ret_val< bool > can_takeoff(const item &it, const std::list< item > *res=nullptr) const
Check player capable of taking off an item.
Definition: player.cpp:2953
hint_rating rate_action_unload(const item &it) const
Definition: player.cpp:3259
bool takeoff(item &it, std::list< item > *res=nullptr)
Takes off an item, returning false on fail.
Definition: player.cpp:2977
hint_rating rate_action_use(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: player.cpp:3318
nc_color border_color
Definition: ui.h:328
int keypress
Definition: ui.h:413
bool filtering
Definition: ui.h:354
pos_scalar w_x_setup
Definition: ui.h:337
int fselected
Definition: ui.h:388
int selected
Definition: ui.h:415
bool allow_anykey
Definition: ui.h:360
int vshift
Definition: ui.h:386
std::vector< uilist_entry > entries
Definition: ui.h:323
bool has_item(const item &it) const
Returns true if this visitable instance contains the item.
Definition: visitable.cpp:95
static constexpr int KEY_NPAGE
Definition: input.h:65
static constexpr int KEY_PPAGE
Definition: input.h:66
static constexpr int KEY_RIGHT
Definition: input.h:40
hint_rating
Hint value used in a hack to decide text color.
Definition: item.h:2257
@ iffy
Item should display as red.
@ good
Item should display as green.
@ cant
Item should display as gray.
void reassign_letter(player &p, item &it)
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define BORDER_COLOR
Definition: output.h:135
const int UILIST_UNBOUND
Definition: ui.h:27
const int UILIST_WAIT_INPUT
Definition: ui.h:26

References _, add_msg(), auto_pickup::player_settings::add_rule(), uilist::addentry(), uilist::allow_anykey, BORDER_COLOR, uilist::border_color, c_light_gray, c_light_green, c_light_red, player::can_takeoff(), Character::can_unwield(), cant, Character::change_side(), player::disassemble(), draw_item_info(), Character::drop(), avatar_action::eat(), uilist::entries, uilist::filtering, uilist::fselected, get_auto_pickup(), good, visitable< T >::has_item(), auto_pickup::player_settings::has_rule(), iffy, item::info(), item::invlet, Character::is_armed(), item::is_favorite, Character::is_wearing(), Character::is_wielding(), KEY_NPAGE, KEY_PPAGE, KEY_RIGHT, uilist::keypress, LEFT_OF_INFO, LEFT_TERMINAL_EDGE, m_info, avatar_action::mend(), catacurses::newwin(), pgettext(), avatar_action::plthrow(), Character::pos(), uilist::query(), Character::rate_action_change_side(), player::rate_action_disassemble(), Character::rate_action_eat(), player::rate_action_mend(), avatar::rate_action_read(), player::rate_action_reload(), player::rate_action_takeoff(), player::rate_action_unload(), player::rate_action_use(), player::rate_action_wear(), avatar::read(), game_menus::inv::reassign_letter(), reload(), auto_pickup::player_settings::remove_rule(), uilist::ret, RIGHT_OF_INFO, RIGHT_TERMINAL_EDGE, uilist::selected, player::takeoff(), TERMX, TERMY, item::tname(), item::type_name(), u, UILIST_UNBOUND, UILIST_WAIT_INPUT, unload(), avatar_action::use_item(), uilist::vshift, uilist::w_x_setup, uilist::w_y_setup, Character::weapon, player::wear(), wield(), and item_info_data::without_getch.

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 431 of file game.cpp.

432{
434}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9249 of file game.cpp.

9250{
9251 return !( get_dangerous_tile( dest_loc ).empty() );
9252}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9271

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 5151 of file game.cpp.

5152{
5153 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
5154 critter_at( p ) == nullptr;
5155}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2689 of file game.cpp.

2690{
2691 if( uquit == QUIT_WATCH ) {
2692 // deny player movement and dodging
2693 u.moves = 0;
2694 // prevent pain from updating
2695 u.set_pain( 0 );
2696 // prevent dodging
2697 u.dodges_left = 0;
2698 return false;
2699 }
2700 if( uquit == QUIT_DIED ) {
2701 if( u.in_vehicle ) {
2702 m.unboard_vehicle( u.pos() );
2703 }
2704 u.place_corpse();
2705 return true;
2706 }
2707 if( uquit == QUIT_SUICIDE ) {
2708 if( u.in_vehicle ) {
2709 m.unboard_vehicle( u.pos() );
2710 }
2711 return true;
2712 }
2713 if( uquit != QUIT_NO ) {
2714 return true;
2715 }
2716 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2717 if( u.is_dead_state() ) {
2719 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2720 uquit = QUIT_WATCH;
2721 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2722 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2724 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2725 uquit = QUIT_DIED;
2726 } else {
2727 // Something funky happened here, just die.
2728 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2729 uquit = QUIT_DIED;
2730 }
2731 return is_game_over();
2732 }
2733 return false;
2734}
int dodges_left
Definition: character.h:616
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:1119
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:187
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3948 of file game.cpp.

3949{
3950 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3951 get_option<int>( "SAFEMODEPROXIMITY" );
3952 return is_hostile_within( distance );
3953}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3960

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3955 of file game.cpp.

3956{
3958}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:189

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3960 of file game.cpp.

3961{
3962 for( auto &critter : u.get_visible_creatures( distance ) ) {
3963 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3964 return critter;
3965 }
3966 }
3967
3968 return nullptr;
3969}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 5157 of file game.cpp.

5158{
5159 return weather::is_in_sunlight( m, p, get_weather().weather_id );
5160}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3594 of file game.cpp.

3595{
3596 const tripoint diff( u.pos() + u.view_offset - p );
3597
3598 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3599 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3600}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 5162 of file game.cpp.

5163{
5164 return weather::is_sheltered( m, p );
5165}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6305 of file game.cpp.

6306{
6307 return zones_manager_open;
6308}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1101

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1585
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1267
void restack(player &p)
Definition: inventory.cpp:398
void unsort()
Definition: inventory.cpp:226
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult 
)

Definition at line 4584 of file game.cpp.

4585{
4586 std::vector<tripoint> traj;
4587 traj.clear();
4588 traj = line_to( s, t, 0, 0 );
4589 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4590 traj = continue_line( traj, force );
4591 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4592
4593 knockback( traj, stun, dam_mult );
4594}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult 
)

Definition at line 4600 of file game.cpp.

4601{
4602 // TODO: make the force parameter actually do something.
4603 // the header file says higher force causes more damage.
4604 // perhaps that is what it should do?
4605 tripoint tp = traj.front();
4606 if( !critter_at( tp ) ) {
4607 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4608 return;
4609 }
4610 std::size_t force_remaining = traj.size();
4611 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4612 if( stun > 0 ) {
4613 targ->add_effect( effect_stunned, 1_turns * stun );
4614 add_msg( _( "%s was stunned!" ), targ->name() );
4615 }
4616 for( size_t i = 1; i < traj.size(); i++ ) {
4617 if( m.impassable( traj[i].xy() ) ) {
4618 targ->setpos( traj[i - 1] );
4619 force_remaining = traj.size() - i;
4620 if( stun != 0 ) {
4621 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4622 add_msg( _( "%s was stunned!" ), targ->name() );
4623 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4624 targ->apply_damage( nullptr, bodypart_id( "torso" ), dam_mult * force_remaining );
4625 targ->check_dead_state();
4626 }
4627 m.bash( traj[i], 2 * dam_mult * force_remaining );
4628 break;
4629 } else if( critter_at( traj[i] ) ) {
4630 targ->setpos( traj[i - 1] );
4631 force_remaining = traj.size() - i;
4632 if( stun != 0 ) {
4633 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4634 add_msg( _( "%s was stunned!" ), targ->name() );
4635 }
4636 traj.erase( traj.begin(), traj.begin() + i );
4637 if( critter_at<monster>( traj.front() ) ) {
4638 add_msg( _( "%s collided with something else and sent it flying!" ),
4639 targ->name() );
4640 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4641 if( guy->male ) {
4642 add_msg( _( "%s collided with someone else and sent him flying!" ),
4643 targ->name() );
4644 } else {
4645 add_msg( _( "%s collided with someone else and sent her flying!" ),
4646 targ->name() );
4647 }
4648 } else if( u.pos() == traj.front() ) {
4649 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4650 }
4651 knockback( traj, stun, dam_mult );
4652 break;
4653 }
4654 targ->setpos( traj[i] );
4655 if( m.has_flag( "LIQUID", targ->pos() ) && !targ->can_drown() && !targ->is_dead() ) {
4656 targ->die( nullptr );
4657 if( u.sees( *targ ) ) {
4658 add_msg( _( "The %s drowns!" ), targ->name() );
4659 }
4660 }
4661 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4662 !targ->is_dead() ) {
4663 targ->die( nullptr );
4664 if( u.sees( *targ ) ) {
4665 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4666 }
4667 }
4668 }
4669 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4670 if( stun > 0 ) {
4671 targ->add_effect( effect_stunned, 1_turns * stun );
4672 add_msg( _( "%s was stunned!" ), targ->name );
4673 }
4674 for( size_t i = 1; i < traj.size(); i++ ) {
4675 if( m.impassable( traj[i].xy() ) ) { // oops, we hit a wall!
4676 targ->setpos( traj[i - 1] );
4677 force_remaining = traj.size() - i;
4678 if( stun != 0 ) {
4679 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4680 if( targ->has_effect( effect_stunned ) ) {
4681 add_msg( _( "%s was stunned!" ), targ->name );
4682 }
4683
4684 std::array<bodypart_id, 8> bps = {{
4685 bodypart_id( "head" ),
4686 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4687 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4688 bodypart_id( "torso" ),
4689 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4690 }
4691 };
4692 for( const bodypart_id &bp : bps ) {
4693 if( one_in( 2 ) ) {
4694 targ->deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4695 }
4696 }
4697 targ->check_dead_state();
4698 }
4699 m.bash( traj[i], 2 * dam_mult * force_remaining );
4700 break;
4701 } else if( critter_at( traj[i] ) ) {
4702 targ->setpos( traj[i - 1] );
4703 force_remaining = traj.size() - i;
4704 if( stun != 0 ) {
4705 add_msg( _( "%s was stunned!" ), targ->name );
4706 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4707 }
4708 traj.erase( traj.begin(), traj.begin() + i );
4709 const tripoint &traj_front = traj.front();
4710 if( critter_at<monster>( traj_front ) ) {
4711 add_msg( _( "%s collided with something else and sent it flying!" ),
4712 targ->name );
4713 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4714 if( guy->male ) {
4715 add_msg( _( "%s collided with someone else and sent him flying!" ),
4716 targ->name );
4717 } else {
4718 add_msg( _( "%s collided with someone else and sent her flying!" ),
4719 targ->name );
4720 }
4721 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4723 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4724 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4725 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4726 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4727 }
4728 knockback( traj, stun, dam_mult );
4729 break;
4730 }
4731 targ->setpos( traj[i] );
4732 }
4733 } else if( u.pos() == tp ) {
4734 if( stun > 0 ) {
4735 u.add_effect( effect_stunned, 1_turns * stun );
4736 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4737 "You were stunned for %d turns!",
4738 stun ),
4739 stun );
4740 }
4741 for( size_t i = 1; i < traj.size(); i++ ) {
4742 if( m.impassable( traj[i] ) ) { // oops, we hit a wall!
4743 u.setpos( traj[i - 1] );
4744 force_remaining = traj.size() - i;
4745 if( stun != 0 ) {
4746 if( u.has_effect( effect_stunned ) ) {
4747 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4748 "You were stunned AGAIN for %d turns!",
4749 force_remaining ),
4750 force_remaining );
4751 } else {
4752 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4753 "You were stunned for %d turns!",
4754 force_remaining ),
4755 force_remaining );
4756 }
4757 u.add_effect( effect_stunned, 1_turns * force_remaining );
4758 std::array<bodypart_id, 8> bps = {{
4759 bodypart_id( "head" ),
4760 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4761 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4762 bodypart_id( "torso" ),
4763 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4764 }
4765 };
4766 for( const bodypart_id &bp : bps ) {
4767 if( one_in( 2 ) ) {
4768 u.deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4769 }
4770 }
4772 }
4773 m.bash( traj[i], 2 * dam_mult * force_remaining );
4774 break;
4775 } else if( critter_at( traj[i] ) ) {
4776 u.setpos( traj[i - 1] );
4777 force_remaining = traj.size() - i;
4778 if( stun != 0 ) {
4779 if( u.has_effect( effect_stunned ) ) {
4780 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4781 "You were stunned AGAIN for %d turns!",
4782 force_remaining ),
4783 force_remaining );
4784 } else {
4785 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4786 "You were stunned for %d turns!",
4787 force_remaining ),
4788 force_remaining );
4789 }
4790 u.add_effect( effect_stunned, 1_turns * force_remaining );
4791 }
4792 traj.erase( traj.begin(), traj.begin() + i );
4793 if( critter_at<monster>( traj.front() ) ) {
4794 add_msg( _( "You collided with something and sent it flying!" ) );
4795 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4796 if( guy->male ) {
4797 add_msg( _( "You collided with someone and sent him flying!" ) );
4798 } else {
4799 add_msg( _( "You collided with someone and sent her flying!" ) );
4800 }
4801 }
4802 knockback( traj, stun, dam_mult );
4803 break;
4804 }
4805 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4806 avatar_action::swim( m, u, u.pos() );
4807 } else {
4808 u.setpos( traj[i] );
4809 }
4810 }
4811 }
4812}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8945
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8469
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:977
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3927 of file game.cpp.

3928{
3929 const float light = natural_light_level( zlev );
3930 return LIGHT_RANGE( light );
3931}
float natural_light_level(int zlev) const
Definition: game.cpp:3867
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 3134 of file game.cpp.

3135{
3136 std::vector<std::string> saves;
3137 for( auto &worldsave : world_generator->active_world->world_saves ) {
3138 saves.push_back( worldsave.player_name() );
3139 }
3140 return saves;
3141}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7539 of file game.cpp.

7540{
7541 std::vector<map_item_stack> ground_items = item_list;
7542 int iInfoHeight = 0;
7543 int iMaxRows = 0;
7544 int width = 0;
7545 int max_name_width = 0;
7546
7547 //find max length of item name and resize window width
7548 for( const map_item_stack &cur_item : ground_items ) {
7549 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7550 if( item_len > max_name_width ) {
7551 max_name_width = item_len;
7552 }
7553 }
7554
7555 tripoint active_pos;
7556 map_item_stack *activeItem = nullptr;
7557
7558 catacurses::window w_items;
7559 catacurses::window w_items_border;
7560 catacurses::window w_item_info;
7561
7562 ui_adaptor ui;
7563 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7564 iInfoHeight = std::min( 25, TERMY / 2 );
7565 iMaxRows = TERMY - iInfoHeight - 2;
7566
7567 width = clamp( max_name_width, 45, TERMX / 3 );
7568
7569 const int offsetX = TERMX - width;
7570
7571 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7572 width - 2, point( offsetX + 1, 1 ) );
7573 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7574 width, point( offsetX, 0 ) );
7575 w_item_info = catacurses::newwin( iInfoHeight, width,
7576 point( offsetX, TERMY - iInfoHeight ) );
7577
7578 if( activeItem ) {
7579 centerlistview( active_pos, width );
7580 }
7581
7582 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7583 } );
7584 ui.mark_resize();
7585
7586 // use previously selected sorting method
7587 bool sort_radius = uistate.list_item_sort != 2;
7588 bool addcategory = !sort_radius;
7589
7590 // reload filter/priority settings on the first invocation, if they were active
7591 if( !uistate.list_item_init ) {
7594 }
7597 }
7600 }
7601 uistate.list_item_init = true;
7602 }
7603
7604 //this stores only those items that match our filter
7605 std::vector<map_item_stack> filtered_items =
7606 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7607 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7608 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7609 int iItemNum = ground_items.size();
7610
7611 const tripoint stored_view_offset = u.view_offset;
7612
7614
7615 int iActive = 0; // Item index that we're looking at
7616 bool refilter = true;
7617 int page_num = 0;
7618 int iCatSortNum = 0;
7619 int iScrollPos = 0;
7620 std::map<int, std::string> mSortCategory;
7621
7622 std::string action;
7623 input_context ctxt( "LIST_ITEMS" );
7624 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7625 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7626 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7627 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7628 ctxt.register_action( "PAGE_DOWN" );
7629 ctxt.register_action( "PAGE_UP" );
7630 ctxt.register_action( "NEXT_TAB" );
7631 ctxt.register_action( "PREV_TAB" );
7632 ctxt.register_action( "HELP_KEYBINDINGS" );
7633 ctxt.register_action( "QUIT" );
7634 ctxt.register_action( "FILTER" );
7635 ctxt.register_action( "RESET_FILTER" );
7636 ctxt.register_action( "EXAMINE" );
7637 ctxt.register_action( "COMPARE" );
7638 ctxt.register_action( "PRIORITY_INCREASE" );
7639 ctxt.register_action( "PRIORITY_DECREASE" );
7640 ctxt.register_action( "SORT" );
7641 ctxt.register_action( "TRAVEL_TO" );
7642
7644
7645 ui.on_redraw( [&]( const ui_adaptor & ) {
7646 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7647
7648 if( ground_items.empty() ) {
7649 wnoutrefresh( w_items_border );
7650 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7651 } else {
7652 int iStartPos = 0;
7653 werase( w_items );
7654 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7655 int iNum = 0;
7656 bool high = false;
7657 bool low = false;
7658 int index = 0;
7659 int iCatSortOffset = 0;
7660
7661 for( int i = 0; i < iStartPos; i++ ) {
7662 if( !mSortCategory[i].empty() ) {
7663 iNum++;
7664 }
7665 }
7666 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7667 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7668 high = true;
7669 low = false;
7670 } else if( index >= lowPStart + iCatSortOffset ) {
7671 high = false;
7672 low = true;
7673 } else {
7674 high = false;
7675 low = false;
7676 }
7677
7678 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7679 int iThisPage = 0;
7680 if( !mSortCategory[iNum].empty() ) {
7681 iCatSortOffset++;
7682 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7683 } else {
7684 if( iNum == iActive ) {
7685 iThisPage = page_num;
7686 }
7687 std::string sText;
7688 if( iter->vIG.size() > 1 ) {
7689 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7690 }
7691 sText += iter->example->tname();
7692 if( iter->vIG[iThisPage].count > 1 ) {
7693 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7694 }
7695
7696 nc_color col = c_light_green;
7697 if( iNum != iActive ) {
7698 if( high ) {
7699 col = c_yellow;
7700 } else if( low ) {
7701 col = c_red;
7702 } else {
7703 col = iter->example->color_in_inventory();
7704 }
7705 }
7706 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7707 const int numw = iItemNum > 9 ? 2 : 1;
7708 const int x = iter->vIG[iThisPage].pos.x;
7709 const int y = iter->vIG[iThisPage].pos.y;
7710 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7711 iNum == iActive ? c_light_green : c_light_gray,
7712 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7714 ++iter;
7715 }
7716 } else {
7717 ++iter;
7718 }
7719 iNum++;
7720 }
7721 iNum = 0;
7722 for( int i = 0; i < iActive; i++ ) {
7723 if( !mSortCategory[i].empty() ) {
7724 iNum++;
7725 }
7726 }
7727 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7728 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7729 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7730 werase( w_item_info );
7731
7732 if( iItemNum > 0 && activeItem ) {
7733 std::vector<iteminfo> vThisItem;
7734 std::vector<iteminfo> vDummy;
7735 activeItem->example->info( true, vThisItem );
7736
7737 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7738 dummy.without_getch = true;
7739 dummy.without_border = true;
7740
7741 draw_item_info( w_item_info, dummy );
7742 }
7743 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7744 wnoutrefresh( w_items_border );
7745 }
7746
7747 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7748 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7749
7750 if( iItemNum > 0 && activeItem ) {
7751 // print info window title: < item name >
7752 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7753 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7754 activeItem->example->display_name() );
7755 wprintw( w_item_info, " >" );
7756 }
7757
7758 wnoutrefresh( w_items );
7759 wnoutrefresh( w_item_info );
7760
7761 if( filter_type ) {
7762 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7763 }
7764 } );
7765
7766 cata::optional<tripoint> trail_start;
7767 cata::optional<tripoint> trail_end;
7768 bool trail_end_x = false;
7769 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7770 trail_end_x );
7771 add_draw_callback( trail_cb );
7772
7773 do {
7774 if( action == "COMPARE" && activeItem ) {
7775 game_menus::inv::compare( u, active_pos );
7776 } else if( action == "FILTER" ) {
7777 filter_type = item_filter_type::FILTER;
7778 ui.invalidate_ui();
7780 .title( _( "Filter:" ) )
7781 .width( 55 )
7782 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7783 .identifier( "item_filter" )
7784 .max_length( 256 )
7785 .edit( sFilter );
7786 refilter = true;
7787 addcategory = !sort_radius;
7789 filter_type = cata::nullopt;
7790 } else if( action == "RESET_FILTER" ) {
7791 sFilter.clear();
7792 filtered_items = ground_items;
7793 refilter = true;
7795 addcategory = !sort_radius;
7796 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7797 std::vector<iteminfo> vThisItem;
7798 std::vector<iteminfo> vDummy;
7799 activeItem->example->info( true, vThisItem );
7800
7801 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7802 vDummy );
7803 info_data.handle_scrolling = true;
7804
7806 return catacurses::newwin( TERMY, width - 5, point_zero );
7807 }, info_data );
7808 } else if( action == "PRIORITY_INCREASE" ) {
7809 filter_type = item_filter_type::HIGH_PRIORITY;
7810 ui.invalidate_ui();
7812 .title( _( "High Priority:" ) )
7813 .width( 55 )
7815 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7816 .identifier( "list_item_priority" )
7817 .max_length( 256 )
7818 .query_string();
7819 refilter = true;
7820 addcategory = !sort_radius;
7822 filter_type = cata::nullopt;
7823 } else if( action == "PRIORITY_DECREASE" ) {
7824 filter_type = item_filter_type::LOW_PRIORITY;
7825 ui.invalidate_ui();
7827 .title( _( "Low Priority:" ) )
7828 .width( 55 )
7830 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7831 .identifier( "list_item_downvote" )
7832 .max_length( 256 )
7833 .query_string();
7834 refilter = true;
7835 addcategory = !sort_radius;
7837 filter_type = cata::nullopt;
7838 } else if( action == "SORT" ) {
7839 if( sort_radius ) {
7840 sort_radius = false;
7841 addcategory = true;
7842 uistate.list_item_sort = 2; // list is sorted by category
7843 } else {
7844 sort_radius = true;
7845 uistate.list_item_sort = 1; // list is sorted by distance
7846 }
7847 highPEnd = -1;
7848 lowPStart = -1;
7849 iCatSortNum = 0;
7850
7851 mSortCategory.clear();
7852 refilter = true;
7853 } else if( action == "TRAVEL_TO" && activeItem ) {
7854 if( !u.sees( u.pos() + active_pos ) ) {
7855 add_msg( _( "You can't see that destination." ) );
7856 }
7857 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7858 u.get_path_avoid() );
7859 if( route.size() > 1 ) {
7860 route.pop_back();
7861 u.set_destination( route );
7862 break;
7863 } else {
7864 add_msg( m_info, _( "You can't travel there." ) );
7865 }
7866 }
7867 if( uistate.list_item_sort == 1 ) {
7868 ground_items = item_list;
7869 } else if( uistate.list_item_sort == 2 ) {
7870 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7871 }
7872
7873 if( refilter ) {
7874 refilter = false;
7875 filtered_items = filter_item_stacks( ground_items, sFilter );
7876 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7877 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7878 iActive = 0;
7879 page_num = 0;
7880 iItemNum = filtered_items.size();
7881 }
7882
7883 if( addcategory ) {
7884 addcategory = false;
7885 iCatSortNum = 0;
7886 mSortCategory.clear();
7887 if( highPEnd > 0 ) {
7888 mSortCategory[0] = _( "HIGH PRIORITY" );
7889 iCatSortNum++;
7890 }
7891 std::string last_cat_name;
7892 for( int i = std::max( 0, highPEnd );
7893 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7894 const std::string &cat_name = filtered_items[i].example->get_category().name();
7895 if( cat_name != last_cat_name ) {
7896 mSortCategory[i + iCatSortNum++] = cat_name;
7897 last_cat_name = cat_name;
7898 }
7899 }
7900 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7901 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7902 }
7903 if( !mSortCategory[0].empty() ) {
7904 iActive++;
7905 }
7906 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7907 }
7908
7909 if( action == "UP" ) {
7910 do {
7911 iActive--;
7912
7913 } while( !mSortCategory[iActive].empty() );
7914 iScrollPos = 0;
7915 page_num = 0;
7916 if( iActive < 0 ) {
7917 iActive = iItemNum - 1;
7918 }
7919 } else if( action == "DOWN" ) {
7920 do {
7921 iActive++;
7922
7923 } while( !mSortCategory[iActive].empty() );
7924 iScrollPos = 0;
7925 page_num = 0;
7926 if( iActive >= iItemNum ) {
7927 iActive = mSortCategory[0].empty() ? 0 : 1;
7928 }
7929 } else if( action == "RIGHT" ) {
7930 if( !filtered_items.empty() && activeItem ) {
7931 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7932 page_num = activeItem->vIG.size() - 1;
7933 }
7934 }
7935 } else if( action == "LEFT" ) {
7936 page_num = std::max( 0, page_num - 1 );
7937 } else if( action == "PAGE_UP" ) {
7938 iScrollPos--;
7939 } else if( action == "PAGE_DOWN" ) {
7940 iScrollPos++;
7941 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7942 u.view_offset = stored_view_offset;
7944 }
7945
7946 active_pos = tripoint_zero;
7947 activeItem = nullptr;
7948
7949 if( mSortCategory[iActive].empty() ) {
7950 auto iter = filtered_items.begin();
7951 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7952 if( mSortCategory[iNum].empty() ) {
7953 ++iter;
7954 }
7955 }
7956 if( iter != filtered_items.end() ) {
7957 active_pos = iter->vIG[page_num].pos;
7958 activeItem = &( *iter );
7959 }
7960 }
7961
7962 if( activeItem ) {
7963 centerlistview( active_pos, width );
7964 trail_start = u.pos();
7965 trail_end = u.pos() + active_pos;
7966 // Actually accessed from the terrain overlay callback `trail_cb` in the
7967 // call to `ui_manager::redraw`.
7968 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7969 trail_end_x = true;
7970 } else {
7971 u.view_offset = stored_view_offset;
7972 trail_start = trail_end = cata::nullopt;
7973 }
7975
7977
7978 action = ctxt.handle_input();
7979 } while( action != "QUIT" );
7980
7981 u.view_offset = stored_view_offset;
7982 return game::vmenu_ret::QUIT;
7983}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1079
std::string list_item_downvote
Definition: game.h:1080
std::string sFilter
Definition: game.h:1078
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7426
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4010
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3447
uistatedata uistate
Definition: game.cpp:270
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7271
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7494 of file game.cpp.

7495{
7496 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7497 // whole reality bubble
7498 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7499
7500 if( mons.empty() && items.empty() ) {
7501 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7502 return;
7503 }
7504
7505 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7506 const auto att_lhs = lhs->attitude_to( u );
7507 const auto att_rhs = rhs->attitude_to( u );
7508
7509 return att_lhs < att_rhs || ( att_lhs == att_rhs
7510 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7511 } );
7512
7513 // If the current list is empty, switch to the non-empty list
7515 if( items.empty() ) {
7516 uistate.vmenu_show_items = false;
7517 }
7518 } else if( mons.empty() ) {
7520 }
7521
7524 while( true ) {
7525 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7528 } else {
7529 break;
7530 }
7531 }
7532
7533 if( ret == game::vmenu_ret::FIRE ) {
7535 }
7537}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7985
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7539
vmenu_ret
Definition: game.h:805
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:7200
void temp_exit_fullscreen()
Definition: game.cpp:536
void reenter_fullscreen()
Definition: game.cpp:546
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:839
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:204
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:183
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:173
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:168
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:178
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7985 of file game.cpp.

7986{
7987 const int iInfoHeight = 15;
7988 const int width = 45;
7989 int offsetX = 0;
7990 int iMaxRows = 0;
7991
7992 catacurses::window w_monsters;
7993 catacurses::window w_monsters_border;
7994 catacurses::window w_monster_info;
7995 catacurses::window w_monster_info_border;
7996
7997 Creature *cCurMon = nullptr;
7998 tripoint iActivePos;
7999
8000 bool hide_ui = false;
8001
8002 ui_adaptor ui;
8003 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
8004 if( hide_ui ) {
8005 ui.position( point_zero, point_zero );
8006 } else {
8007 offsetX = TERMX - width;
8008 iMaxRows = TERMY - iInfoHeight - 1;
8009
8010 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
8011 1 ) );
8012 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
8013 0 ) );
8014 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
8015 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
8016 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
8017 TERMY - iInfoHeight ) );
8018
8019 if( cCurMon ) {
8020 centerlistview( iActivePos, width );
8021 }
8022
8023 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
8024 }
8025 } );
8026 ui.mark_resize();
8027
8028 const int max_gun_range = u.weapon.gun_range( &u );
8029
8030 const tripoint stored_view_offset = u.view_offset;
8032
8033 int iActive = 0; // monster index that we're looking at
8034
8035 std::string action;
8036 input_context ctxt( "LIST_MONSTERS" );
8037 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
8038 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
8039 ctxt.register_action( "NEXT_TAB" );
8040 ctxt.register_action( "PREV_TAB" );
8041 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
8042 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
8043 ctxt.register_action( "QUIT" );
8044 if( bVMonsterLookFire ) {
8045 ctxt.register_action( "look" );
8046 ctxt.register_action( "fire" );
8047 }
8048 ctxt.register_action( "HELP_KEYBINDINGS" );
8049
8050 // first integer is the row the attitude category string is printed in the menu
8051 std::map<int, Creature::Attitude> mSortCategory;
8052
8053 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
8054 const auto attitude = monster_list[i]->attitude_to( u );
8055 if( attitude != last_attitude ) {
8056 mSortCategory[i + mSortCategory.size()] = attitude;
8057 last_attitude = attitude;
8058 }
8059 }
8060
8061 ui.on_redraw( [&]( const ui_adaptor & ) {
8062 if( !hide_ui ) {
8063 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
8064 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8065 true );
8066
8067 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
8068 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
8069
8070 if( monster_list.empty() ) {
8071 werase( w_monsters );
8072 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
8073 _( "You don't see any monsters around you!" ) );
8074 } else {
8075 werase( w_monsters );
8076
8077 const int iNumMonster = monster_list.size();
8078 const int iMenuSize = monster_list.size() + mSortCategory.size();
8079
8080 const int numw = iNumMonster > 999 ? 4 :
8081 iNumMonster > 99 ? 3 :
8082 iNumMonster > 9 ? 2 : 1;
8083
8084 // given the currently selected monster iActive. get the selected row
8085 int iSelPos = iActive;
8086 for( auto &ia : mSortCategory ) {
8087 int index = ia.first;
8088 if( index <= iSelPos ) {
8089 ++iSelPos;
8090 } else {
8091 break;
8092 }
8093 }
8094 int iStartPos = 0;
8095 // use selected row get the start row
8096 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
8097
8098 // get first visible monster and category
8099 int iCurMon = iStartPos;
8100 auto CatSortIter = mSortCategory.cbegin();
8101 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
8102 ++CatSortIter;
8103 --iCurMon;
8104 }
8105
8106 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
8107 for( int y = 0; y < endY; ++y ) {
8108 if( CatSortIter != mSortCategory.cend() ) {
8109 const int iCurPos = iStartPos + y;
8110 const int iCatPos = CatSortIter->first;
8111 if( iCurPos == iCatPos ) {
8112 const std::string cat_name = Creature::get_attitude_ui_data(
8113 CatSortIter->second ).first.translated();
8114 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
8115 ++CatSortIter;
8116 continue;
8117 }
8118 }
8119 // select current monster
8120 const auto critter = monster_list[iCurMon];
8121 const bool selected = iCurMon == iActive;
8122 ++iCurMon;
8123 if( critter->sees( g->u ) ) {
8124 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
8125 }
8126 bool is_npc = false;
8127 const monster *m = dynamic_cast<monster *>( critter );
8128 const npc *p = dynamic_cast<npc *>( critter );
8129 nc_color name_color = critter->basic_symbol_color();
8130
8131 if( selected ) {
8132 name_color = hilite( name_color );
8133 }
8134
8135 if( m != nullptr ) {
8136 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
8137 } else {
8138 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
8139 is_npc = true;
8140 }
8141
8142 if( selected && !get_safemode().empty() ) {
8143 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
8144
8145 std::string sSafemode;
8146 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8147 sSafemode = _( "<R>emove from safemode Blacklist" );
8148 } else {
8149 sSafemode = _( "<A>dd to safemode Blacklist" );
8150 }
8151
8152 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
8153 c_white, c_light_green, sSafemode );
8154 }
8155
8157 std::string sText;
8158
8159 if( m != nullptr ) {
8160 m->get_HP_Bar( color, sText );
8161 } else {
8162 std::tie( sText, color ) =
8163 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
8164 }
8165 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
8166
8167 if( m != nullptr ) {
8168 const auto att = m->get_attitude();
8169 sText = att.first;
8170 color = att.second;
8171 } else if( p != nullptr ) {
8172 sText = npc_attitude_name( p->get_attitude() );
8173 color = p->symbol_color();
8174 }
8175 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
8176
8177 const int mon_dist = rl_dist( u.pos(), critter->pos() );
8178 const int numd = mon_dist > 999 ? 4 :
8179 mon_dist > 99 ? 3 :
8180 mon_dist > 9 ? 2 : 1;
8181
8182 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
8183 selected ? c_light_green : c_light_gray,
8184 "%*d %s",
8185 numd, mon_dist,
8186 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
8187 }
8188
8189 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
8190 iActive + 1 );
8191 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
8192
8193 werase( w_monster_info );
8194 if( cCurMon ) {
8195 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
8196 }
8197
8198 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8199 true );
8200
8201 if( bVMonsterLookFire ) {
8202 mvwprintw( w_monster_info_border, point_east, "< " );
8203 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
8204 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
8205
8206 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8207 wprintw( w_monster_info_border, " " );
8208 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
8209 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
8210 }
8211 wprintw( w_monster_info_border, " >" );
8212 }
8213
8214 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
8215 point_south );
8216 }
8217
8218 wnoutrefresh( w_monsters_border );
8219 wnoutrefresh( w_monster_info_border );
8220 wnoutrefresh( w_monsters );
8221 wnoutrefresh( w_monster_info );
8222 }
8223 } );
8224
8225 cata::optional<tripoint> trail_start;
8226 cata::optional<tripoint> trail_end;
8227 bool trail_end_x = false;
8228 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
8229 trail_end_x );
8230 add_draw_callback( trail_cb );
8231
8232 do {
8233 if( action == "UP" ) {
8234 iActive--;
8235 if( iActive < 0 ) {
8236 if( monster_list.empty() ) {
8237 iActive = 0;
8238 } else {
8239 iActive = static_cast<int>( monster_list.size() ) - 1;
8240 }
8241 }
8242 } else if( action == "DOWN" ) {
8243 iActive++;
8244 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8245 iActive = 0;
8246 }
8247 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8248 u.view_offset = stored_view_offset;
8250 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8251 const auto m = dynamic_cast<monster *>( cCurMon );
8252 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8253
8254 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8256 }
8257 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8258 if( !get_safemode().empty() ) {
8259 const auto m = dynamic_cast<monster *>( cCurMon );
8260 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8261
8262 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8264 }
8265 } else if( action == "look" ) {
8266 hide_ui = true;
8267 ui.mark_resize();
8268 look_around();
8269 hide_ui = false;
8270 ui.mark_resize();
8271 } else if( action == "fire" ) {
8272 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8273 u.last_target = shared_from( *cCurMon );
8275 u.view_offset = stored_view_offset;
8276 return game::vmenu_ret::FIRE;
8277 }
8278 }
8279
8280 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8281 cCurMon = monster_list[iActive];
8282 iActivePos = cCurMon->pos() - u.pos();
8283 centerlistview( iActivePos, width );
8284 trail_start = u.pos();
8285 trail_end = cCurMon->pos();
8286 // Actually accessed from the terrain overlay callback `trail_cb` in the
8287 // call to `ui_manager::redraw`.
8288 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8289 trail_end_x = false;
8290 } else {
8291 cCurMon = nullptr;
8292 iActivePos = tripoint_zero;
8293 u.view_offset = stored_view_offset;
8294 trail_start = trail_end = cata::nullopt;
8295 }
8297
8299
8300 action = ctxt.handle_input();
8301 } while( action != "QUIT" );
8302
8303 u.view_offset = stored_view_offset;
8304
8305 return game::vmenu_ret::QUIT;
8306}
double recoil
Definition: character.h:618
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6120
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1857
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4894
bool bVMonsterLookFire
Definition: game.h:1083
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7190
npc_attitude get_attitude() const
Definition: npc.cpp:3136
weak_ptr_fast< Creature > last_target
Definition: player.h:690
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2542
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2855 of file game.cpp.

2856{
2859 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2862
2863 using namespace std::placeholders;
2864
2865 const std::string worldpath = get_world_base_save_path() + "/";
2866 const std::string playerpath = worldpath + name.base_path();
2867
2868 // Now load up the master game data; factions (and more?)
2869 load_master();
2870 u = avatar();
2871 u.name = name.player_name();
2872 // This should be initialized more globally (in player/Character constructor)
2874 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2875 return false;
2876 }
2877
2879
2881
2882 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2883 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2884
2885#if defined(__ANDROID__)
2886 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2887 std::bind( &game::load_shortcuts, this, _1 ) );
2888#endif
2889
2890 // Now that the player's worn items are updated, their sight limits need to be
2891 // recalculated. (This would be cleaner if u.worn were private.)
2893
2894 if( !gamemode ) {
2895 gamemode = std::make_unique<special_game>();
2896 }
2897
2898 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2899 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2900
2901 init_autosave();
2902 get_auto_pickup().load_character(); // Load character auto pickup rules
2903 get_auto_notes_settings().load(); // Load character auto notes settings
2904 get_safemode().load_character(); // Load character safemode rules
2905 zone_manager::get_manager().load_zones(); // Load character world zones
2906 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2907 JsonIn jsin( stream );
2908 uistate.deserialize( jsin );
2909 } );
2910 reload_npcs();
2915 update_map( u );
2916 for( auto &e : u.inv_dump() ) {
2917 e->set_owner( g->u );
2918 }
2919 // legacy, needs to be here as we access the map.
2920 if( !u.getID().is_valid() ) {
2921 // player does not have a real id, so assign a new one,
2922 u.setID( assign_npc_id() );
2923 // The vehicle stores the IDs of the boarded players, so update it, too.
2924 if( u.in_vehicle ) {
2926 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2927 vp->part().passenger_id = u.getID();
2928 }
2929 }
2930 }
2931
2932 // populate calendar caches now, after active world is set, but before we do
2933 // anything else, to ensure they pick up the correct value from the save's
2934 // worldoptions
2935 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2936 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2937
2938 u.reset();
2939
2940 return true;
2941}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:461
std::vector< item * > inv_dump()
Definition: character.cpp:8969
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1701
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3620
Definition: json.h:177
Definition: avatar.h:54
void load_map_memory()
Definition: avatar.cpp:132
bool is_valid() const
Definition: character_id.h:19
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1978
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:958
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2036
void load_master()
Definition: game.cpp:2824
void validate_mounted_npcs()
Definition: game.cpp:1993
character_id assign_npc_id()
Definition: game.cpp:3941
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11794
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2012
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:276
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2831 of file game.cpp.

2832{
2833 world_generator->init();
2834 const WORLDPTR wptr = world_generator->get_world( world );
2835 if( !wptr ) {
2836 return false;
2837 }
2838 if( wptr->world_saves.empty() ) {
2839 debugmsg( "world '%s' contains no saves", world );
2840 return false;
2841 }
2842
2843 try {
2844 world_generator->set_active_world( wptr );
2845 g->setup();
2846 g->load( wptr->world_saves.front() );
2847 } catch( const std::exception &err ) {
2848 debugmsg( "cannot load world '%s': %s", world, err.what() );
2849 return false;
2850 }
2851
2852 return true;
2853}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 436 of file game.cpp.

437{
438 // core data can be loaded only once and must be first
439 // anyway.
441
443}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:523
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 445 of file game.cpp.

446{
448}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:453

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Definition at line 632 of file game.cpp.

633{
634 // TODO: fix point types
635 load_map( tripoint_abs_sm( pos_sm ) );
636}
void load_map(const tripoint &pos_sm)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:632
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm)

Definition at line 638 of file game.cpp.

639{
640 m.load( pos_sm, true );
641 grid_tracker_ptr->load( m );
642}
void load(const tripoint &w, bool update_vehicles)
Load submaps into grid.
Definition: map.cpp:6494

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2824 of file game.cpp.

2825{
2826 using namespace std::placeholders;
2827 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2828 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2829}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1207
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 896 of file game.cpp.

897{
898 const int radius = HALF_MAPSIZE - 1;
899 // uses submap coordinates
900 std::vector<shared_ptr_fast<npc>> just_added;
901 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
902 const character_id &id = temp->getID();
903 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
904 [id]( const shared_ptr_fast<npc> &n ) {
905 return n->getID() == id;
906 } );
907 if( found != active_npc.end() ) {
908 continue;
909 }
910 if( temp->is_active() ) {
911 continue;
912 }
913 if( temp->has_companion_mission() ) {
914 continue;
915 }
916
917 const tripoint sm_loc = temp->global_sm_location();
918 // NPCs who are out of bounds before placement would be pushed into bounds
919 // This can cause NPCs to teleport around, so we don't want that
920 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
921 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
922 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
923 continue;
924 }
925
926 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
927 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
928 temp->place_on_map();
929 if( !m.inbounds( temp->pos() ) ) {
930 continue;
931 }
932 // In the rare case the npc was marked for death while
933 // it was on the overmap. Kill it.
934 if( temp->marked_for_death ) {
935 temp->die( nullptr );
936 } else {
937 active_npc.push_back( temp );
938 just_added.push_back( temp );
939 }
940 }
941
942 for( const auto &npc : just_added ) {
943 npc->on_load();
944 }
945
946 npcs_dirty = false;
947}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2655
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2979 of file game.cpp.

2980{
2981 ui.new_context( msg );
2982 std::vector<mod_id> missing;
2983 std::vector<mod_id> available;
2984
2985 for( const mod_id &e : packs ) {
2986 if( e.is_valid() ) {
2987 available.emplace_back( e );
2988 ui.add_entry( e->name() );
2989 } else {
2990 missing.push_back( e );
2991 }
2992 }
2993
2994 ui.show();
2995 for( const auto &e : available ) {
2996 const MOD_INFORMATION &mod = *e;
2997 load_data_from_dir( mod.path, mod.ident.str(), ui );
2998 ui.proceed();
2999 }
3000
3001 for( const auto &e : missing ) {
3002 debugmsg( "unknown content %s", e.c_str() );
3003 }
3004
3005 return missing.empty();
3006}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 322 of file game.cpp.

323{
324 // UI stuff, not mod-specific per definition
325 inp_mngr.init(); // Load input config JSON
326 // Init mappings for loading the json stuff
328 fullscreen = false;
329 was_fullscreen = false;
330 show_panel_adm = false;
332
333 // These functions do not load stuff from json.
334 // The content they load/initialize is hardcoded into the program.
335 // Therefore they can be loaded here.
336 // If this changes (if they load data from json), they have to
337 // be moved to game::load_mod or game::load_core_data
338
341}
bool was_fullscreen
Definition: game.h:1065
bool fullscreen
Definition: game.h:1064
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2309
void load_global()

References fullscreen, get_auto_pickup(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2943 of file game.cpp.

2944{
2945 auto &mods = world_generator->active_world->active_mod_order;
2946
2947 // remove any duplicates whilst preserving order (fixes #19385)
2948 std::set<mod_id> found;
2949 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2950 if( found.count( e ) ) {
2951 return true;
2952 } else {
2953 found.insert( e );
2954 return false;
2955 }
2956 } ), mods.end() );
2957
2958 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2959 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2960 return e->core;
2961} ) ) {
2962 mods.insert( mods.begin(), mod_id( "dda" ) );
2963 }
2964
2966 // this code does not care about mod dependencies,
2967 // it assumes that those dependencies are static and
2968 // are resolved during the creation of the world.
2969 // That means world->active_mod_order contains a list
2970 // of mods in the correct order.
2971 load_packs( _( "Loading files" ), mods, ui );
2972
2973 // Load additional mods from that world-specific folder
2974 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2975
2977}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( )

Definition at line 6850 of file game.cpp.

6851{
6853 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6854 false );
6855 return result.position;
6856}

References center, look_around(), Character::pos(), u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6858 of file game.cpp.

6861{
6862 bVMonsterLookFire = false;
6863 // TODO: Make this `true`
6864 const bool allow_zlev_move = m.has_zlevels() && get_option<bool>( "FOV_3D" );
6865
6867
6868 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6869 int &lx = lp.x;
6870 int &ly = lp.y;
6871 int &lz = lp.z;
6872
6873 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6874 bool fast_scroll = false;
6875
6876 std::unique_ptr<ui_adaptor> ui;
6877 catacurses::window w_info;
6878 if( show_window ) {
6879 ui = std::make_unique<ui_adaptor>();
6880 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6881 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6883
6884 // If particularly small, base height on panel width irrespective of other elements.
6885 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6886 if( height < panel_width / 2 ) {
6887 height = panel_width / 2;
6888 }
6889
6890 int la_y = 0;
6891 int la_x = TERMX - panel_width;
6892 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6893 if( position == "left" ) {
6894 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6896 } else {
6897 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6898 }
6899 }
6900 int la_h = height;
6901 int la_w = panel_width;
6902 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6903
6904 ui.position_from_window( w_info );
6905 } );
6906 ui->mark_resize();
6907 }
6908
6909 std::string action;
6910 input_context ctxt( "LOOK" );
6911 ctxt.set_iso( true );
6912 ctxt.register_directions();
6913 ctxt.register_action( "COORDINATE" );
6914 ctxt.register_action( "LEVEL_UP" );
6915 ctxt.register_action( "LEVEL_DOWN" );
6916 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6917 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6918 ctxt.register_action( "SELECT" );
6919 if( peeking ) {
6920 ctxt.register_action( "throw_blind" );
6921 }
6922 if( !select_zone ) {
6923 ctxt.register_action( "TRAVEL_TO" );
6924 ctxt.register_action( "LIST_ITEMS" );
6925 }
6926 ctxt.register_action( "MOUSE_MOVE" );
6927 ctxt.register_action( "CENTER" );
6928
6929 ctxt.register_action( "debug_scent" );
6930 ctxt.register_action( "debug_scent_type" );
6931 ctxt.register_action( "debug_temp" );
6932 ctxt.register_action( "debug_visibility" );
6933 ctxt.register_action( "debug_lighting" );
6934 ctxt.register_action( "debug_radiation" );
6935 ctxt.register_action( "debug_submap_grid" );
6936 ctxt.register_action( "debug_hour_timer" );
6937 ctxt.register_action( "CONFIRM" );
6938 ctxt.register_action( "QUIT" );
6939 ctxt.register_action( "HELP_KEYBINDINGS" );
6940 if( use_tiles ) {
6941 ctxt.register_action( "zoom_out" );
6942 ctxt.register_action( "zoom_in" );
6943 }
6944#if defined(TILES)
6945 ctxt.register_action( "toggle_pixel_minimap" );
6946#endif // TILES
6947
6948 const int old_levz = get_levz();
6949 const int min_levz = std::max( old_levz - fov_3d_z_range, -OVERMAP_DEPTH );
6950 const int max_levz = std::min( old_levz + fov_3d_z_range, OVERMAP_HEIGHT );
6951
6952 m.update_visibility_cache( old_levz );
6954
6955 bool blink = true;
6957
6958 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6959
6960 if( show_window && ui ) {
6961 ui->on_redraw( [&]( const ui_adaptor & ) {
6962 werase( w_info );
6963 draw_border( w_info );
6964
6965 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6966
6967 std::string extended_descr_text = string_format( _( "%s - %s" ),
6968 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6969 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6970 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6971 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6972 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6973#if defined(TILES)
6974 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6975 ctxt.get_desc( "toggle_pixel_minimap" ),
6976 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6977#endif // TILES
6978
6979 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6980 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6981 fast_scroll_text );
6982#if defined(TILES)
6983 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6984 pixel_minimap_text );
6985#endif // TILES
6986
6987 int first_line = 1;
6988 const int last_line = getmaxy( w_info ) - 3;
6989 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6990
6991 wnoutrefresh( w_info );
6992 } );
6993 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6994 draw_look_around_cursor( lp, cache );
6995 } );
6996 add_draw_callback( ter_indicator_cb );
6997 }
6998
6999 cata::optional<tripoint> zone_start;
7000 cata::optional<tripoint> zone_end;
7001 bool zone_blink = false;
7002 bool zone_cursor = true;
7003 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
7004 zone_cursor, is_moving_zone );
7005 add_draw_callback( zone_cb );
7006
7007 is_looking = true;
7008 const tripoint prev_offset = u.view_offset;
7009#if defined(TILES)
7010 const int prev_tileset_zoom = tileset_zoom;
7011 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
7012 get_zoom() != 4 ) {
7013 zoom_out();
7014 }
7016#endif
7017 do {
7018 u.view_offset = center - u.pos();
7019 if( select_zone ) {
7020 if( has_first_point ) {
7021 zone_start = start_point;
7022 zone_end = lp;
7023 } else {
7024 zone_start = lp;
7025 zone_end = cata::nullopt;
7026 }
7027 // Actually accessed from the terrain overlay callback `zone_cb` in the
7028 // call to `ui_manager::redraw`.
7029 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7030 zone_blink = blink;
7031 }
7032
7033 if( is_moving_zone ) {
7034 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
7035 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
7036 // Actually accessed from the terrain overlay callback `zone_cb` in the
7037 // call to `ui_manager::redraw`.
7038 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7039 zone_blink = blink;
7040 }
7043 if( ( select_zone && has_first_point ) || is_moving_zone ) {
7044 ctxt.set_timeout( BLINK_SPEED );
7045 }
7046
7047 //Wait for input
7048 // only specify a timeout here if "EDGE_SCROLL" is enabled
7049 // otherwise use the previously set timeout
7050 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
7051 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
7052 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
7053 if( edge_scrolling ) {
7054 action = ctxt.handle_input( scroll_timeout );
7055 } else {
7056 action = ctxt.handle_input();
7057 }
7058 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
7059 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
7060 blink = true; // Always draw blink symbols when moving cursor
7061 } else if( action == "TIMEOUT" ) {
7062 blink = !blink;
7063 }
7064 if( action == "LIST_ITEMS" ) {
7066 } else if( action == "TOGGLE_FAST_SCROLL" ) {
7067 fast_scroll = !fast_scroll;
7068 } else if( action == "toggle_pixel_minimap" ) {
7070
7071 if( show_window && ui ) {
7072 ui->mark_resize();
7073 }
7074 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
7075 if( !allow_zlev_move ) {
7076 continue;
7077 }
7078
7079 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
7080 lz = clamp( lz + dz, min_levz, max_levz );
7081 center.z = clamp( center.z + dz, min_levz, max_levz );
7082
7083 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
7084 u.view_offset.z = center.z - u.posz();
7086 } else if( action == "TRAVEL_TO" ) {
7087 if( !u.sees( lp ) ) {
7088 add_msg( _( "You can't see that destination." ) );
7089 continue;
7090 }
7091
7092 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
7093 if( route.size() > 1 ) {
7094 route.pop_back();
7095 u.set_destination( route );
7096 } else {
7097 add_msg( m_info, _( "You can't travel there." ) );
7098 continue;
7099 }
7100 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
7102 display_scent();
7103 }
7104 } else if( action == "debug_temp" ) {
7107 }
7108 } else if( action == "debug_lighting" ) {
7111 }
7112 } else if( action == "debug_transparency" ) {
7115 }
7116 } else if( action == "debug_radiation" ) {
7119 }
7120 } else if( action == "debug_submap_grid" ) {
7121 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
7122 } else if( action == "debug_hour_timer" ) {
7124 } else if( action == "EXTENDED_DESCRIPTION" ) {
7126 } else if( action == "CENTER" ) {
7127 center = u.pos();
7128 lp = u.pos();
7129 u.view_offset.z = 0;
7130 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
7131 // This block is structured this way so that edge scroll can work
7132 // whether the mouse is moving at the edge or simply stationary
7133 // at the edge. But even if edge scroll isn't in play, there's
7134 // other things for us to do here.
7135
7136 if( edge_scrolling ) {
7137 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
7138 } else if( action == "MOUSE_MOVE" ) {
7139 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
7140 if( mouse_pos ) {
7141 lx = mouse_pos->x;
7142 ly = mouse_pos->y;
7143 }
7144 }
7145 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
7146 if( fast_scroll ) {
7147 vec->x *= soffset;
7148 vec->y *= soffset;
7149 }
7150
7151 lx = lx + vec->x;
7152 ly = ly + vec->y;
7153 center.x = center.x + vec->x;
7154 center.y = center.y + vec->y;
7155 } else if( action == "throw_blind" ) {
7156 result.peek_action = PA_BLIND_THROW;
7157 } else if( action == "zoom_in" ) {
7158 center.x = lp.x;
7159 center.y = lp.y;
7160 zoom_in();
7162 } else if( action == "zoom_out" ) {
7163 center.x = lp.x;
7164 center.y = lp.y;
7165 zoom_out();
7167 }
7168 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
7169 action != "throw_blind" );
7170
7171 if( m.has_zlevels() && center.z != old_levz ) {
7172 m.invalidate_map_cache( old_levz );
7173 m.build_map_cache( old_levz );
7174 u.view_offset.z = 0;
7175 }
7176
7177 ctxt.reset_timeout();
7178 u.view_offset = prev_offset;
7179 zone_cb = nullptr;
7180 is_looking = false;
7181
7183 bVMonsterLookFire = true;
7184
7185 if( action == "CONFIRM" || action == "SELECT" ) {
7186 result.position = is_moving_zone ? zone_start : lp;
7187 }
7188
7189#if defined(TILES)
7190 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
7191 // Reset the tileset zoom to the previous value
7192 set_zoom( prev_tileset_zoom );
7194 }
7195#endif
7196
7197 return result;
7198}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2405
void set_zoom(int level)
Definition: game.cpp:7349
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5963
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6837
int get_zoom() const
Definition: game.cpp:7361
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5615
void invalidate_map_cache(const int zlev)
Definition: map.h:458
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2277
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3400
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5956 of file game.cpp.

5957{
5958 editmap edit;
5959 return edit.edit();
5960}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3357 of file game.cpp.

3358{
3360 if( ui ) {
3361 ui->mark_resize();
3362 }
3363}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 3099 of file game.cpp.

3100{
3101 return *memorial_logger_ptr;
3102}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 4048 of file game.cpp.

4049{
4050 const monster_visible_info &mon_visible = u.get_mon_visible();
4051 const auto &unique_types = mon_visible.unique_types;
4052 const auto &unique_mons = mon_visible.unique_mons;
4053 const auto &dangerous = mon_visible.dangerous;
4054
4055 const int width = getmaxx( w ) - 2 * hor_padding;
4056 const int maxheight = getmaxy( w );
4057
4058 const int startrow = 0;
4059
4060 // Print the direction headings
4061 // Reminder:
4062 // 7 0 1 unique_types uses these indices;
4063 // 6 8 2 0-7 are provide by direction_from()
4064 // 5 4 3 8 is used for local monsters (for when we explain them below)
4065
4066 const std::array<std::string, 8> dir_labels = {{
4067 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
4068 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
4069 }
4070 };
4071 std::array<int, 8> widths;
4072 for( int i = 0; i < 8; i++ ) {
4073 widths[i] = utf8_width( dir_labels[i] );
4074 }
4075 std::array<int, 8> xcoords;
4076 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
4077 xcoords[0] = xcoords[4] = width / 3;
4078 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
4079 xcoords[5] = xcoords[6] = xcoords[7] = 0;
4080 //for the alignment of the 1,2,3 rows on the right edge
4081 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
4082 for( int i = 0; i < 8; i++ ) {
4083 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
4084 : ( dangerous[i] ? c_light_red : c_light_gray );
4085 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
4086 }
4087
4088 // Print the symbols of all monsters in all directions.
4089 for( int i = 0; i < 8; i++ ) {
4090 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
4091
4092 // The list of symbols needs a space on each end.
4093 int symroom = ( width / 3 ) - widths[i] - 2;
4094 const int typeshere_npc = unique_types[i].size();
4095 const int typeshere_mon = unique_mons[i].size();
4096 const int typeshere = typeshere_mon + typeshere_npc;
4097 for( int j = 0; j < typeshere && j < symroom; j++ ) {
4098 nc_color c;
4099 std::string sym;
4100 if( symroom < typeshere && j == symroom - 1 ) {
4101 // We've run out of room!
4102 c = c_white;
4103 sym = "+";
4104 } else if( j < typeshere_npc ) {
4105 switch( unique_types[i][j]->get_attitude() ) {
4106 case NPCATT_KILL:
4107 c = c_red;
4108 break;
4109 case NPCATT_FOLLOW:
4110 c = c_light_green;
4111 break;
4112 default:
4113 c = c_pink;
4114 break;
4115 }
4116 sym = "@";
4117 } else {
4118 const mtype &mt = *unique_mons[i][j - typeshere_npc];
4119 c = mt.color;
4120 sym = mt.sym;
4121 }
4122 mvwprintz( w, pr, c, sym );
4123
4124 pr.x++;
4125 }
4126 }
4127
4128 // Now we print their full names!
4129
4130 std::set<const mtype *> listed_mons;
4131
4132 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
4133 // is blank.
4134 point pr( hor_padding, 4 + startrow );
4135
4136 // Print monster names, starting with those at location 8 (nearby).
4137 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
4138 // Separate names by some number of spaces (more for local monsters).
4139 int namesep = ( j == 8 ? 2 : 1 );
4140 for( const mtype *type : unique_mons[j] ) {
4141 if( pr.y >= maxheight ) {
4142 // no space to print to anyway
4143 break;
4144 }
4145 if( listed_mons.count( type ) > 0 ) {
4146 // this type is already printed.
4147 continue;
4148 }
4149 listed_mons.insert( type );
4150
4151 const mtype &mt = *type;
4152 const std::string name = mt.nname();
4153
4154 // Move to the next row if necessary. (The +2 is for the "Z ").
4155 if( pr.x + 2 + utf8_width( name ) >= width ) {
4156 pr.y++;
4157 pr.x = hor_padding;
4158 }
4159
4160 if( pr.y < maxheight ) { // Don't print if we've overflowed
4161 mvwprintz( w, pr, mt.color, mt.sym );
4162 pr.x += 2; // symbol and space
4163 nc_color danger = c_dark_gray;
4164 if( mt.difficulty >= 30 ) {
4165 danger = c_red;
4166 } else if( mt.difficulty >= 16 ) {
4167 danger = c_light_red;
4168 } else if( mt.difficulty >= 8 ) {
4169 danger = c_white;
4170 } else if( mt.agro > 0 ) {
4171 danger = c_light_gray;
4172 }
4173 mvwprintz( w, pr, danger, name );
4174 pr.x += utf8_width( name ) + namesep;
4175 }
4176 }
4177 }
4178}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< const mtype * > unique_mons[9]
Definition: avatar.h:47
bool dangerous[8]
Definition: avatar.h:50
std::vector< npc * > unique_types[9]
Definition: avatar.h:46
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:253
nc_color color
Definition: mtype.h:258
int difficulty
Definition: mtype.h:264
int agro
e.g.
Definition: mtype.h:269

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 4180 of file game.cpp.

4181{
4182 int newseen = 0;
4183 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
4184 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
4185 safe_proxy_dist;
4186
4187 monster_visible_info &mon_visible = u.get_mon_visible();
4188 auto &new_seen_mon = mon_visible.new_seen_mon;
4189 auto &unique_types = mon_visible.unique_types;
4190 auto &unique_mons = mon_visible.unique_mons;
4191 auto &dangerous = mon_visible.dangerous;
4192
4193 // 7 0 1 unique_types uses these indices;
4194 // 6 8 2 0-7 are provide by direction_from()
4195 // 5 4 3 8 is used for local monsters (for when we explain them below)
4196 for( auto &t : unique_types ) {
4197 t.clear();
4198 }
4199 for( auto &m : unique_mons ) {
4200 m.clear();
4201 }
4202 std::fill( dangerous, dangerous + 8, false );
4203
4204 const tripoint view = u.pos() + u.view_offset;
4205 new_seen_mon.clear();
4206
4207 // TODO: no reason to have it static here
4208 static time_point previous_turn = calendar::start_of_cataclysm;
4209 const time_duration sm_ignored_time = time_duration::from_turns(
4210 get_option<int>( "SAFEMODEIGNORETURNS" ) );
4211
4213 monster *m = dynamic_cast<monster *>( c );
4214 npc *p = dynamic_cast<npc *>( c );
4215 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
4216 const int mx = POSX + ( c->posx() - view.x );
4217 const int my = POSY + ( c->posy() - view.y );
4218 int index = 8;
4219 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
4220 // for compatibility with old code, see diagram below, it explains the values for index,
4221 // also might need revisiting one z-levels are in.
4222 switch( dir_to_mon ) {
4226 index = 7;
4227 break;
4229 case direction::NORTH:
4231 index = 0;
4232 break;
4236 index = 1;
4237 break;
4239 case direction::WEST:
4241 index = 6;
4242 break;
4244 case direction::CENTER:
4246 index = 8;
4247 break;
4249 case direction::EAST:
4251 index = 2;
4252 break;
4256 index = 5;
4257 break;
4259 case direction::SOUTH:
4261 index = 4;
4262 break;
4266 index = 3;
4267 break;
4268 }
4269 }
4270
4271 rule_state safemode_state = RULE_NONE;
4272 const bool safemode_empty = get_safemode().empty();
4273
4274 if( m != nullptr ) {
4275 //Safemode monster check
4276 monster &critter = *m;
4277
4278 const monster_attitude matt = critter.attitude( &u );
4279 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4280 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4281
4282 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4283 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4284 if( index < 8 && critter.sees( g->u ) ) {
4285 dangerous[index] = true;
4286 }
4287
4288 if( !safemode_empty || mon_dist <= iProxyDist ) {
4289 bool passmon = false;
4290 if( critter.ignoring > 0 ) {
4291 if( safe_mode != SAFE_MODE_ON ) {
4292 critter.ignoring = 0;
4293 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4294 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4295 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4296 passmon = true;
4297 }
4298 critter.lastseen_turn = calendar::turn;
4299 }
4300
4301 if( !passmon ) {
4302 newseen++;
4303 new_seen_mon.push_back( shared_from( critter ) );
4304 }
4305 }
4306 }
4307
4308 std::vector<const mtype *> &vec = unique_mons[index];
4309 if( std::find( vec.begin(), vec.end(), critter.type ) == vec.end() ) {
4310 vec.push_back( critter.type );
4311 }
4312 } else if( p != nullptr ) {
4313 //Safe mode NPC check
4314
4315 const int npc_dist = rl_dist( u.pos(), p->pos() );
4316 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4317 npc_dist );
4318
4319 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4320 p->get_attitude() == NPCATT_KILL ) ) {
4321 if( !safemode_empty || npc_dist <= iProxyDist ) {
4322 newseen++;
4323 }
4324 }
4325 unique_types[index].push_back( p );
4326 }
4327 }
4328
4329 if( newseen > mostseen ) {
4330 if( newseen - mostseen == 1 ) {
4331 if( !new_seen_mon.empty() ) {
4332 monster &critter = *new_seen_mon.back();
4334 string_format( _( "%s spotted!" ), critter.name() ) );
4335 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4336 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4338 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4339 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4340 // Triffids present. We ain't got TIME to adrenaline comedown!
4341 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4342 u.mod_pain( 3 ); // Does take it out of you, though
4343 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4344 }
4345 }
4346 } else {
4347 //Hostile NPC
4349 _( "Hostile survivor spotted!" ) );
4350 }
4351 } else {
4353 }
4355 if( safe_mode == SAFE_MODE_ON ) {
4357 }
4358 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4359 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4360 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4361 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4363 add_msg( m_info, _( "Safe mode ON!" ) );
4364 }
4365 }
4366
4367 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4369 }
4370
4371 previous_turn = calendar::turn;
4372 mostseen = newseen;
4373}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1247
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1790
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1066
cata::optional< time_point > lastseen_turn
Definition: monster.h:506
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2074
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:272
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:54
@ MATT_FOLLOW
Definition: monster.h:60
@ MATT_ATTACK
Definition: monster.h:61
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), detail::find(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4410 of file game.cpp.

4411{
4412 cleanup_dead();
4413
4414 for( monster &critter : all_monsters() ) {
4415 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4416 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4417 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4418 critter.pos().to_string(), m.tername( critter.pos() ) );
4419 dbg( DL::Error ) << msg;
4420 add_msg( m_debug, msg );
4421 bool okay = false;
4422 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4423 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4424 critter.setpos( dest );
4425 okay = true;
4426 break;
4427 }
4428 }
4429 if( !okay ) {
4430 // die of "natural" cause (overpopulation is natural)
4431 critter.die( nullptr );
4432 }
4433 }
4434
4435 if( !critter.is_dead() ) {
4436 critter.process_items();
4437 }
4438
4439 if( !critter.is_dead() ) {
4440 critter.process_turn();
4441 }
4442
4443 m.creature_in_field( critter );
4444 if( calendar::once_every( 1_days ) ) {
4445 if( critter.has_flag( MF_MILKABLE ) ) {
4446 critter.refill_udders();
4447 }
4448 critter.try_reproduce();
4449 }
4450 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4451 critter.made_footstep = false;
4452 // Controlled critters don't make their own plans
4453 if( !critter.has_effect( effect_ai_controlled ) ) {
4454 // Formulate a path to follow
4455 critter.plan();
4456 }
4457 critter.move(); // Move one square, possibly hit u
4458 critter.process_triggers();
4459 m.creature_in_field( critter );
4460 }
4461
4462 if( !critter.is_dead() &&
4463 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4464 u.get_power_level() >= 25_kJ &&
4465 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4466 !critter.is_hallucination() ) {
4467 u.mod_power_level( -25_kJ );
4468 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4470 _( "Your motion alarm goes off!" ) );
4471 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4472 u.wake_up();
4473 }
4474 }
4475 }
4476
4477 cleanup_dead();
4478
4479 // The remaining monsters are all alive, but may be outside of the reality bubble.
4480 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4481 // monster::die function is not called.
4482 for( monster &critter : all_monsters() ) {
4483 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4484 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4485 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4486 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4487 despawn_monster( critter );
4488 }
4489 }
4490
4491 // Now, do active NPCs.
4492 for( npc &guy : g->all_npcs() ) {
4493 int turns = 0;
4494 if( guy.is_mounted() ) {
4495 guy.check_mount_is_spooked();
4496 }
4497 m.creature_in_field( guy );
4498 if( !guy.has_effect( effect_npc_suspend ) ) {
4499 guy.process_turn();
4500 }
4501 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4502 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4503 ) {
4504 int moves = guy.moves;
4505 guy.move();
4506 if( moves == guy.moves ) {
4507 // Count every time we exit npc::move() without spending any moves.
4508 turns++;
4509 }
4510
4511 // Turn on debug mode when in infinite loop
4512 // It has to be done before the last turn, otherwise
4513 // there will be no meaningful debug output.
4514 if( turns == 9 ) {
4515 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4516 guy.name );
4517 debug_mode = true;
4518 }
4519 }
4520
4521 // If we spun too long trying to decide what to do (without spending moves),
4522 // Invoke cognitive suspension to prevent an infinite loop.
4523 if( turns == 10 ) {
4524 add_msg( _( "%s faints!" ), guy.name );
4525 guy.reboot();
4526 }
4527
4528 if( !guy.is_dead() ) {
4529 guy.npc_update_body();
4530 }
4531 }
4532 cleanup_dead();
4533}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1985
units::energy get_power_level() const
Definition: character.cpp:1965
void wake_up()
Definition: avatar.cpp:947
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), motion_alarm, calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2352 of file game.cpp.

2354{
2355 const int rate = get_option<int>( "EDGE_SCROLL" );
2356 auto ret = std::make_pair( tripoint_zero, last );
2357 if( rate == -1 ) {
2358 // Fast return when the option is disabled.
2359 return ret;
2360 }
2361 // Ensure the parameters are used even if the #if below is false
2362 ( void ) ctxt;
2363 ( void ) speed;
2364 ( void ) iso;
2365#if (defined TILES || defined _WIN32 || defined WINDOWS)
2366 auto now = std::chrono::steady_clock::now();
2367 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2368 return ret;
2369 } else {
2371 }
2372 const input_event event = ctxt.get_raw_input();
2373 if( event.type == CATA_INPUT_MOUSE ) {
2374 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2375 if( event.mouse_pos.x <= threshold.x ) {
2376 ret.first.x -= speed;
2377 if( iso ) {
2378 ret.first.y -= speed;
2379 }
2380 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2381 ret.first.x += speed;
2382 if( iso ) {
2383 ret.first.y += speed;
2384 }
2385 }
2386 if( event.mouse_pos.y <= threshold.y ) {
2387 ret.first.y -= speed;
2388 if( iso ) {
2389 ret.first.x += speed;
2390 }
2391 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2392 ret.first.y += speed;
2393 if( iso ) {
2394 ret.first.x -= speed;
2395 }
2396 }
2397 ret.second = ret.first;
2398 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2399 ret.first = ret.second;
2400 }
2401#endif
2402 return ret;
2403}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2414 of file game.cpp.

2415{
2416 // overmap has no iso mode
2420 return ret.first;
2421}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2352
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1117
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1118

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2405 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2786 of file game.cpp.

2787{
2788 const std::string save_dir = get_world_base_save_path();
2789 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2790 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2791 const std::string prefix = base64_encode( u.name ) + ".";
2792
2793 if( !assure_dir_exist( graveyard_dir ) ) {
2794 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2795 }
2796
2797 if( !assure_dir_exist( graveyard_save_dir ) ) {
2798 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2799 }
2800
2801 const auto save_files = get_files_from_path( prefix, save_dir );
2802 if( save_files.empty() ) {
2803 debugmsg( "could not find save files in '%s'", save_dir );
2804 }
2805
2806 for( const auto &src_path : save_files ) {
2807 const std::string dst_path = graveyard_save_dir +
2808 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2809
2810 if( rename_file( src_path, dst_path ) ) {
2811 continue;
2812 }
2813
2814 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2815
2816 if( remove_file( src_path ) ) {
2817 continue;
2818 }
2819
2820 debugmsg( "could not remove file '%s'", src_path );
2821 }
2822}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5424 of file game.cpp.

5425{
5426 const optional_vpart_position vp = m.veh_at( u.pos() );
5427 if( !vp ) {
5428 debugmsg( "Tried to exit non-existent vehicle." );
5429 return;
5430 }
5431 vehicle *const veh = &vp->vehicle();
5432 if( u.pos() == dest_loc ) {
5433 debugmsg( "Need somewhere to dismount towards." );
5434 return;
5435 }
5436 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5437 // TODO:: make dir() const correct!
5438 const units::angle d = ray.dir();
5439 add_msg( _( "You dive from the %s." ), veh->name );
5440 m.unboard_vehicle( u.pos() );
5441 u.moves -= 200;
5442 // Dive three tiles in the direction of tox and toy
5443 fling_creature( &u, d, 30, true );
5444 // Hit the ground according to vehicle speed
5445 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5446 if( veh->velocity > 0 ) {
5447 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5448 } else {
5449 fling_creature( &u, veh->face.dir() + 180_degrees,
5450 -( veh->velocity ) / static_cast<float>( 100 ) );
5451 }
5452 }
5453}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:10314

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3867 of file game.cpp.

3868{
3869 // ignore while underground or above limits
3870 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3871 return LIGHT_AMBIENT_MINIMAL;
3872 }
3873
3874 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3875 // Already found the light level for now?
3876 return latest_lightlevels[zlev];
3877 }
3878
3879 float ret = LIGHT_AMBIENT_MINIMAL;
3880
3881 // Sunlight/moonlight related stuff
3883 if( !weather.lightning_active ) {
3885 } else {
3886 // Recent lightning strike has lit the area
3888 }
3889
3891
3892 // Artifact light level changes here. Even though some of these only have an effect
3893 // aboveground it is cheaper performance wise to simply iterate through the entire
3894 // list once instead of twice.
3895 float mod_ret = -1;
3896 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3897 // will trump a lower one.
3898 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3899 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3900 const time_duration left = e->when - calendar::turn;
3901 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3902 if( left > 25_turns ) {
3903 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3904 // and the last 25 scale back towards normal.
3905 } else {
3906 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3907 }
3908 }
3910 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3911 mod_ret = std::max<float>( ret, default_daylight_level() );
3912 }
3913 // If we had a changed light level due to an artifact event then it overwrites
3914 // the natural light level.
3915 if( mod_ret > -1 ) {
3916 ret = mod_ret;
3917 }
3918
3919 // Cap everything to our minimum light level
3920 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3921
3922 latest_lightlevels[zlev] = ret;
3923
3924 return ret;
3925}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1090
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5555 of file game.cpp.

5556{
5557 enum choices : int {
5558 talk = 0,
5559 swap_pos,
5560 push,
5561 examine_wounds,
5562 use_item,
5563 sort_armor,
5564 attack,
5565 disarm,
5566 steal
5567 };
5568
5569 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5570
5571 uilist amenu;
5572
5573 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5574 amenu.addentry( talk, true, 't', _( "Talk" ) );
5575 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5576 !u.is_mounted(), 's', _( "Swap positions" ) );
5577 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5578 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5579 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5580 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5581 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5582 if( !who.is_player_ally() ) {
5583 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5584 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5585 }
5586
5587 amenu.query();
5588
5589 const int choice = amenu.ret;
5590 if( choice == talk ) {
5591 who.talk_to_u();
5592 } else if( choice == swap_pos ) {
5593 if( !prompt_dangerous_tile( who.pos() ) ) {
5594 return true;
5595 }
5596 // TODO: Make NPCs protest when displaced onto dangerous crap
5597 add_msg( _( "You swap places with %s." ), who.name );
5598 swap_critters( u, who );
5599 // TODO: Make that depend on stuff
5600 u.mod_moves( -200 );
5601 } else if( choice == push ) {
5602 // TODO: Make NPCs protest when displaced onto dangerous crap
5603 tripoint oldpos = who.pos();
5604 who.move_away_from( u.pos(), true );
5605 u.mod_moves( -20 );
5606 if( oldpos != who.pos() ) {
5607 add_msg( _( "%s moves out of the way." ), who.name );
5608 } else {
5609 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5610 }
5611 } else if( choice == examine_wounds ) {
5612 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5613
5614 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5615 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5616 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5617 0.0f, 0.0f );
5618 } else if( choice == use_item ) {
5619 static const std::string heal_string( "heal" );
5620 const auto will_accept = []( const item & it ) {
5621 const auto use_fun = it.get_use( heal_string );
5622 if( use_fun == nullptr ) {
5623 return false;
5624 }
5625
5626 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5627
5628 return actor != nullptr &&
5629 actor->limb_power >= 0 &&
5630 actor->head_power >= 0 &&
5631 actor->torso_power >= 0;
5632 };
5633 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5634
5635 if( !loc ) {
5636 add_msg( _( "Never mind" ) );
5637 return false;
5638 }
5639 item &used = *loc;
5640 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5641 if( did_use ) {
5642 // Note: exiting a body part selection menu counts as use here
5643 u.mod_moves( -300 );
5644 }
5645 } else if( choice == sort_armor ) {
5646 who.sort_armor();
5647 u.mod_moves( -100 );
5648 } else if( choice == attack ) {
5649 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5650 u.melee_attack( who, true );
5651 who.on_attacked( u );
5652 }
5653 } else if( choice == disarm ) {
5654 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5655 u.disarm( who );
5656 }
5657 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5658 u.steal( who );
5659 }
5660
5661 return true;
5662}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5859
bool in_sleep_state() const override
Definition: character.cpp:9330
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:307
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2340
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9254
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:5081
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:730
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1446
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2516
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2264
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:552

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 5026 of file game.cpp.

5027{
5028 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
5029}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 10272 of file game.cpp.

10273{
10274 // TODO: Move this to a character method
10275 if( !u.is_mounted() ) {
10276 const item muscle( "muscle" );
10277 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
10278 if( u.has_active_bionic( bid ) ) {// active power gen
10279 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
10280 } else if( u.has_bionic( bid ) ) {// passive power gen
10281 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
10282 }
10283 }
10284
10285 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
10286 if( u.movement_mode_is( CMM_RUN ) ) {
10287 u.mod_power_level( -55_J );
10288 } else {
10289 u.mod_power_level( -35_J );
10290 }
10291 }
10292 }
10293
10294 if( u.movement_mode_is( CMM_RUN ) ) {
10295 if( !u.can_run() ) {
10297 }
10298 }
10299
10300 // apply martial art move bonuses
10301 u.martial_arts_data->ma_onmove_effects( u );
10302
10304}
@ CMM_RUN
Definition: character.h:98
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1327
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1617
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1926
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1875
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 10306 of file game.cpp.

10307{
10308#if defined(TILES)
10309 tilecontext->on_options_changed();
10310#endif
10311 grid_tracker_ptr->on_options_changed();
10312}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1486 of file handle_action.cpp.

1487{
1488 uilist as_m;
1489
1490 as_m.text = _( "What do you want to consume?" );
1491
1492 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1493 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1494 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1495 as_m.query();
1496
1497 switch( as_m.ret ) {
1498 case 0:
1500 break;
1501 case 1:
1503 break;
1504 case 2:
1506 break;
1507 default:
1508 break;
1509 }
1510}
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ open_gate()

void game::open_gate ( const tripoint p)

Definition at line 5419 of file game.cpp.

5420{
5421 gates::open_gate( p, u );
5422}
void open_gate(const tripoint &pos, player &p)
opens the gate via player's activity
Definition: gates.cpp:236

References gates::open_gate(), and u.

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4535 of file game.cpp.

4536{
4537 std::vector<npc *> travelling_npcs;
4538 static constexpr int move_search_radius = 600;
4539 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4540 if( !elem ) {
4541 continue;
4542 }
4543 npc *npc_to_add = elem.get();
4544 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4545 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4546 travelling_npcs.push_back( npc_to_add );
4547 }
4548 }
4549 for( auto &elem : travelling_npcs ) {
4550 if( elem->has_omt_destination() ) {
4551 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4552 //recalculate path, we got distracted doing something else probably
4553 elem->omt_path.clear();
4554 }
4555 if( elem->omt_path.empty() ) {
4556 const tripoint_abs_omt &from = elem->global_omt_location();
4557 const tripoint_abs_omt &to = elem->goal;
4558 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4560 if( elem->omt_path.empty() ) {
4561 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4562 elem->get_name(), from.to_string(), to.to_string() );
4563 elem->goal = npc::no_goal_point;
4564 elem->mission = NPC_MISSION_NULL;
4565 }
4566 } else {
4567 if( elem->omt_path.back() == elem->global_omt_location() ) {
4568 elem->omt_path.pop_back();
4569 }
4570 // TODO: fix point types
4571 elem->travel_overmap(
4572 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4573 }
4574 reload_npcs();
4575 }
4576 }
4577 return;
4578}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:1030
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2192
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5914 of file game.cpp.

5915{
5916 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5917 if( !p ) {
5918 return;
5919 }
5920
5921 if( p->z != 0 ) {
5922 const tripoint old_pos = u.pos();
5923 vertical_move( p->z, false, true );
5924
5925 if( old_pos != u.pos() ) {
5926 look_around();
5927 vertical_move( p->z * -1, false, true );
5928 }
5929 return;
5930 }
5931
5932 if( m.impassable( u.pos() + *p ) ) {
5933 return;
5934 }
5935
5936 peek( u.pos() + *p );
5937}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:971

References _, choose_direction(), map::impassable(), look_around(), m, peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5939 of file game.cpp.

5940{
5941 u.moves -= 200;
5942 tripoint prev = u.pos();
5943 u.setpos( p );
5944 tripoint center = p;
5945 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5946 true );
5947 u.setpos( prev );
5948
5949 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5950 item_location loc;
5951 avatar_action::plthrow( u, loc, p );
5952 }
5954}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11580 of file game.cpp.

11581{
11582 if( !calendar::once_every( 1_hours ) ) {
11583 return;
11584 }
11585 // Create a new NPC?
11586 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11587 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11588 return;
11589 }
11590
11591 float density = get_option<float>( "NPC_DENSITY" );
11592 static constexpr int density_search_radius = 60;
11593 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11594 if( npc_num > 0.0 ) {
11595 // 100%, 80%, 64%, 52%, 41%, 33%...
11596 density *= std::pow( 0.8f, npc_num );
11597 }
11598
11599 if( !x_in_y( density, 100 ) ) {
11600 return;
11601 }
11602 bool spawn_allowed = false;
11604 int counter = 0;
11605 while( !spawn_allowed ) {
11606 if( counter >= 10 ) {
11607 return;
11608 }
11609 static constexpr int radius_spawn_range = 120;
11610 const tripoint_abs_omt u_omt = u.global_omt_location();
11611 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11612 rng( -radius_spawn_range, radius_spawn_range ) );
11613 spawn_point.z() = 0;
11614 const oter_id oter = overmap_buffer.ter( spawn_point );
11615 // shouldn't spawn on lakes or rivers.
11616 if( !is_river_or_lake( oter ) ) {
11617 spawn_allowed = true;
11618 }
11619 counter += 1;
11620 }
11621 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11622 tmp->normalize();
11623 tmp->randomize();
11624 std::string new_fac_id = "solo_";
11625 new_fac_id += tmp->name;
11626 // create a new "lone wolf" faction for this one NPC
11627 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11628 faction_id( "no_faction" ) );
11629 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11630 // adds the npc to the correct overmap.
11631 // Only spawn random NPCs on z-level 0
11632 // TODO: fix point types
11633 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11634 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11636 tmp->form_opinion( u );
11637 tmp->mission = NPC_MISSION_NULL;
11638 tmp->long_term_goal_action();
11639 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11640 tmp->getID() ) );
11641 // This will make the new NPC active- if its nearby to the player
11642 load_npcs();
11643}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:539

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 10004 of file game.cpp.

10005{
10006 if( dest_loc.z != u.posz() && !via_ramp ) {
10007 // No vertical phasing yet
10008 return false;
10009 }
10010
10011 //probability travel through walls but not water
10012 tripoint dest = dest_loc;
10013 // tile is impassable
10014 int tunneldist = 0;
10015 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
10016 while( m.impassable( dest ) ||
10017 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
10018 //add 1 to tunnel distance for each impassable tile in the line
10019 tunneldist += 1;
10020 //Being dimensionally anchored prevents quantum shenanigans.
10021 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
10023 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
10024 return false;
10025 }
10026
10027 if( tunneldist > 24 ) {
10028 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
10029 return false;
10030 }
10031
10032 dest.x += d.x;
10033 dest.y += d.y;
10034 }
10035
10036 if( tunneldist != 0 ) {
10037 if( ( tunneldist - 1 ) * 100_kJ
10038 > //The first 100 was already taken up by the bionic's activation cost.
10039 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
10040 if( tunneldist * 100_kJ >
10042 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
10043 } else {
10044 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
10045 ( 100 * tunneldist ) );
10046 }
10047 return false;
10048 }
10049
10050 if( u.in_vehicle ) {
10051 m.unboard_vehicle( u.pos() );
10052 }
10053
10054 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
10055 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
10056 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
10057 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
10058 u.moves -= ( 50 + ( tunneldist * 50 ) );
10059 u.setpos( dest );
10060
10061 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
10062 m.board_vehicle( u.pos(), &u );
10063 }
10064
10065 u.grab( OBJECT_NONE );
10067 m.creature_on_trap( u );
10068 return true;
10069 }
10070
10071 return false;
10072}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3268
units::energy get_max_power_level() const
Definition: character.cpp:1970
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1198
void on_move_effects()
Definition: game.cpp:10272
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1044
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5885 of file game.cpp.

5886{
5887 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5888 _( "There is nothing to pick up nearby." ),
5889 ACTION_PICKUP, false );
5890 if( !examp_ ) {
5891 return;
5892 }
5893 pickup( *examp_ );
5894}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5896 of file game.cpp.

5897{
5898 // Highlight target
5899 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5900 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5901 } );
5902 add_draw_callback( hilite_cb );
5903
5904 pickup::pick_up( p, 0 );
5905}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5907 of file game.cpp.

5908{
5909 pickup::pick_up( u.pos(), 1 );
5910}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4974 of file game.cpp.

4975{
4976 // TODO: change this into an assert, it must never happen.
4977 if( id.is_null() ) {
4978 return nullptr;
4979 }
4980 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4981}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4974

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4983 of file game.cpp.

4987{
4989 if( forced || can_place_monster( *mon, center ) ) {
4990 where = center;
4991 }
4992
4993 // This loop ensures the monster is placed as close to the center as possible,
4994 // but all places that equally far from the center have the same probability.
4995 for( int r = 1; r <= radius && !where; ++r ) {
4997 }
4998
4999 if( !where ) {
5000 return nullptr;
5001 }
5002 mon->spawn( *where );
5003 return critter_tracker->add( mon ) ? mon.get() : nullptr;
5004}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4956
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4940

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4964 of file game.cpp.

4965{
4966 return place_critter_around( id, p, 0 );
4967}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4969 of file game.cpp.

4970{
4971 return place_critter_around( mon, p, 0 );
4972}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 5006 of file game.cpp.

5007{
5008 // TODO: change this into an assert, it must never happen.
5009 if( id.is_null() ) {
5010 return nullptr;
5011 }
5012 return place_critter_within( make_shared_fast<monster>( id ), range );
5013}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:5006

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 5015 of file game.cpp.

5017{
5018 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
5019 if( !where ) {
5020 return nullptr;
5021 }
5022 mon->spawn( *where );
5023 return critter_tracker->add( mon ) ? mon.get() : nullptr;
5024}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9642 of file game.cpp.

9643{
9644 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9645 if( const cata::optional<std::string> label = vp1.get_label() ) {
9646 add_msg( m_info, _( "Label here: %s" ), *label );
9647 }
9648 std::string signage = m.get_signage( dest_loc );
9649 if( !signage.empty() ) {
9650 if( !u.has_trait( trait_ILLITERATE ) ) {
9651 add_msg( m_info, _( "The sign says: %s" ), signage );
9652 } else {
9653 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9654 }
9655 }
9656 if( m.has_graffiti_at( dest_loc ) ) {
9657 if( !u.has_trait( trait_ILLITERATE ) ) {
9658 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9659 } else {
9660 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9661 }
9662 }
9663 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9664 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9665 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9666 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9667 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9668 dest_loc ) );
9669 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9670 }
9671 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9672 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9673 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9674 dest_loc ) );
9675 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9676 }
9677 }
9678 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9679 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9680 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9681 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9682 if( u.is_mounted() ) {
9683 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9684 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9685 } else {
9686 const bodypart_id bp = u.get_random_body_part();
9687 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9688 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9689 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9690 body_part_name_accusative( bp->token ),
9691 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9692 dest_loc ) );
9693 }
9694 }
9695 }
9696 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9697 u.add_effect( effect_bouldering, 1_turns, num_bp );
9698 } else if( u.has_effect( effect_bouldering ) ) {
9700 }
9701 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9702 u.add_effect( effect_no_sight, 1_turns, num_bp );
9703 } else if( u.has_effect( effect_no_sight ) ) {
9705 }
9706
9707 // If we moved out of the nonant, we need update our map data
9708 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9709 add_msg( _( "The water puts out the flames!" ) );
9711 if( u.is_mounted() ) {
9712 monster *mon = u.mounted_creature.get();
9713 if( mon->has_effect( effect_onfire ) ) {
9715 }
9716 }
9717 }
9718
9719 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9720 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9721 // Immobile monsters can't be displaced.
9722 monster &critter = *mon_ptr;
9723 // TODO: handling for ridden creatures other than players mount.
9724 if( !critter.has_effect( effect_ridden ) ) {
9725 if( u.is_mounted() ) {
9726 std::vector<tripoint> valid;
9727 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9728 if( is_empty( jk ) ) {
9729 valid.push_back( jk );
9730 }
9731 }
9732 if( !valid.empty() ) {
9733 critter.move_to( random_entry( valid ) );
9734 add_msg( _( "You push the %s out of the way." ), critter.name() );
9735 } else {
9736 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9737 return u.pos().xy();
9738 }
9739 } else {
9740 critter.move_to( u.pos(), false,
9741 true ); // Force the movement even though the player is there right now.
9742 add_msg( _( "You displace the %s." ), critter.name() );
9743 }
9744 } else if( !u.has_effect( effect_riding ) ) {
9745 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9746 return u.pos().xy();
9747 }
9748 }
9749
9750 // If the player is in a vehicle, unboard them from the current part
9751 if( u.in_vehicle ) {
9752 m.unboard_vehicle( u.pos() );
9753 }
9754 // Move the player
9755 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9756 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9757 vertical_shift( dest_loc.z );
9758 }
9759
9760 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9761 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9762 vp1 ) ) {
9763 u.stop_hauling();
9764 }
9765 u.setpos( dest_loc );
9766 if( u.is_mounted() ) {
9767 monster *mon = u.mounted_creature.get();
9768 mon->setpos( dest_loc );
9769 mon->process_triggers();
9770 m.creature_in_field( *mon );
9771 }
9772 point submap_shift = update_map( u );
9773 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9774 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9775 // If you must use it you can calculate the position in the new, shifted system with
9776 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9777
9778 //Auto pulp or butcher and Auto foraging
9779 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9781
9782 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9783 if( forage_type != "off" ) {
9784 const auto forage = [&]( const tripoint & pos ) {
9785 const auto &xter_t = m.ter( pos ).obj().examine;
9786 const auto &xfurn_t = m.furn( pos ).obj().examine;
9787 const bool forage_everything = forage_type == "both";
9788 const bool forage_bushes = forage_everything || forage_type == "bushes";
9789 const bool forage_trees = forage_everything || forage_type == "trees";
9790 if( xter_t == &iexamine::none ) {
9791 return;
9792 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9793 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9794 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9795 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9796 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9797 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9798 ) {
9799 xter_t( u, pos );
9800 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9801 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9802 ) {
9803 xfurn_t( u, pos );
9804 }
9805 };
9806
9807 for( auto &elem : adjacentDir ) {
9808 forage( u.pos() + direction_XY( elem ) );
9809 }
9810 }
9811
9812 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9813 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9814 std::vector<item *> corpses;
9815
9816 for( item &it : m.i_at( u.pos() ) ) {
9817 corpses.push_back( &it );
9818 }
9819
9820 if( !corpses.empty() ) {
9821 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9822 for( item *it : corpses ) {
9823 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9824 }
9825 }
9826 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9827 const auto pulp = [&]( const tripoint & pos ) {
9828 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9829 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9830 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9832 u.activity.placement = m.getabs( pos );
9833 u.activity.auto_resume = true;
9834 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9835 return;
9836 }
9837 }
9838 };
9839
9840 if( pulp_butcher == "pulp_adjacent" ) {
9841 for( auto &elem : adjacentDir ) {
9842 pulp( u.pos() + direction_XY( elem ) );
9843 }
9844 } else {
9845 pulp( u.pos() );
9846 }
9847 }
9848 }
9849
9850 //Autopickup
9851 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9852 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9853 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9854 pickup::pick_up( u.pos(), -1 );
9855 }
9856
9857 // If the new tile is a boardable part, board it
9858 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9859 m.board_vehicle( u.pos(), &u );
9860 }
9861
9862 // Traps!
9863 // Try to detect.
9865 if( u.is_mounted() ) {
9867 } else {
9868 m.creature_on_trap( u );
9869 }
9870 // Drench the player if swimmable
9871 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9872 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9873 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9874 }
9875
9876 // List items here
9877 if( !m.has_flag( "SEALED", u.pos() ) ) {
9878 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9879 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9880 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9881 add_msg( _( "There's something here, but you can't see what it is." ) );
9882 } else if( m.has_items( u.pos() ) ) {
9883 std::vector<std::string> names;
9884 std::vector<size_t> counts;
9885 std::vector<item> items;
9886 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9887
9888 std::string next_tname = tmpitem.tname();
9889 std::string next_dname = tmpitem.display_name();
9890 bool by_charges = tmpitem.count_by_charges();
9891 bool got_it = false;
9892 for( size_t i = 0; i < names.size(); ++i ) {
9893 if( by_charges && next_tname == names[i] ) {
9894 counts[i] += tmpitem.charges;
9895 got_it = true;
9896 break;
9897 } else if( next_dname == names[i] ) {
9898 counts[i] += 1;
9899 got_it = true;
9900 break;
9901 }
9902 }
9903 if( !got_it ) {
9904 if( by_charges ) {
9905 names.push_back( tmpitem.tname( tmpitem.charges ) );
9906 counts.push_back( tmpitem.charges );
9907 } else {
9908 names.push_back( tmpitem.display_name( 1 ) );
9909 counts.push_back( 1 );
9910 }
9911 items.push_back( tmpitem );
9912 }
9913 if( names.size() > 10 ) {
9914 break;
9915 }
9916 }
9917 for( size_t i = 0; i < names.size(); ++i ) {
9918 if( !items[i].count_by_charges() ) {
9919 names[i] = items[i].display_name( counts[i] );
9920 } else {
9921 names[i] = items[i].tname( counts[i] );
9922 }
9923 }
9924 int and_the_rest = 0;
9925 for( size_t i = 0; i < names.size(); ++i ) {
9926 //~ number of items: "<number> <item>"
9927 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9928 names[i] = string_format( fmt, counts[i], names[i] );
9929 // Skip the first two.
9930 if( i > 1 ) {
9931 and_the_rest += counts[i];
9932 }
9933 }
9934 if( names.size() == 1 ) {
9935 add_msg( _( "You see here %s." ), names[0] );
9936 } else if( names.size() == 2 ) {
9937 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9938 } else if( names.size() == 3 ) {
9939 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9940 } else if( and_the_rest < 7 ) {
9941 add_msg( vgettext( "You see here %s, %s and %d more item.",
9942 "You see here %s, %s and %d more items.",
9943 and_the_rest ),
9944 names[0], names[1], and_the_rest );
9945 } else {
9946 add_msg( _( "You see here %s and many more items." ), names[0] );
9947 }
9948 }
9949 }
9950 }
9951
9952 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9953 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9954 add_msg( _( "There are vehicle controls here." ) );
9955 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9956 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9957 }
9958 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9959 u.is_mounted() ) {
9960 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9961 }
9962 return submap_shift;
9963}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1755
bool is_hauling() const
Definition: character.cpp:9194
void stop_hauling()
Definition: character.cpp:9185
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1617
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:11103
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6295
std::string furnname(const tripoint &p)
Definition: map.cpp:1464
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2317
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7691
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4750
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7680
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2307
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2293
void setpos(const tripoint &p) override
Definition: monster.cpp:237
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1493
void process_triggers()
Definition: monster.cpp:1192
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:848
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3605
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3570
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2042
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2021
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2030
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2012
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3584
string_id< zone_type > zone_type_id
Definition: type_id.h:189

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9965 of file game.cpp.

9966{
9967 // if player is teleporting around, they don't bring their horse with them
9968 if( u.is_mounted() ) {
9970 u.mounted_creature->remove_effect( effect_ridden );
9971 u.mounted_creature = nullptr;
9972 }
9973 // offload the active npcs.
9974 unload_npcs();
9975 for( monster &critter : all_monsters() ) {
9976 despawn_monster( critter );
9977 }
9978 if( u.in_vehicle ) {
9979 m.unboard_vehicle( u.pos() );
9980 }
9981
9983 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9984 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9985 for( int z = minz; z <= maxz; z++ ) {
9986 m.clear_vehicle_list( z );
9987 }
9989 // offset because load_map expects the coordinates of the top left corner, but the
9990 // player will be centered in the middle of the map.
9991 // TODO: fix point types
9992 const tripoint map_sm_pos(
9993 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9994 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9995 load_map( map_sm_pos );
9996 load_npcs();
9997 m.spawn_monsters( true ); // Static monsters
9999 // update weather now as it could be different on the new location
10001 place_player( player_pos );
10002}
point place_player(const tripoint &dest)
Definition: game.cpp:9642
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:949
void update_overmap_seen()
Definition: game.cpp:11281
level_cache & access_cache(int zlev)
Definition: map.cpp:8522
void clear_vehicle_list(int zlev)
Definition: map.cpp:327
void clear_vehicle_cache()
Definition: map.cpp:309
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:339

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 845 of file game.cpp.

848{
849 std::vector<std::string> search_types = omt_search_types;
850 if( search_types.empty() ) {
851 vehicle veh( id );
852 if( veh.can_float() ) {
853 search_types.push_back( "river" );
854 search_types.push_back( "lake" );
855 } else {
856 search_types.push_back( "field" );
857 search_types.push_back( "road" );
858 }
859 }
860 for( const std::string &search_type : search_types ) {
861 omt_find_params find_params;
862 find_params.must_see = false;
863 find_params.cant_see = false;
864 find_params.types.emplace_back( search_type, ot_match_type::type );
865 // find nearest road
866 find_params.min_distance = min_distance;
867 find_params.search_range = max_distance;
868 // if player spawns underground, park their car on the surface.
869 const tripoint_abs_omt omt_origin( origin, 0 );
870 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
871 // try place vehicle there.
872 tinymap target_map;
873 target_map.load( project_to<coords::sm>( goal ), false );
874 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
875 static constexpr std::array<units::angle, 4> angles = {{
876 0_degrees, 90_degrees, 180_degrees, 270_degrees
877 }
878 };
879 vehicle *veh = target_map.add_vehicle(
880 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
881 if( veh ) {
882 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
883 veh->sm_pos = ms_to_sm_remain( abs_local );
884 veh->pos = abs_local.xy();
886 veh->tracking_on = true;
887 target_map.save();
888 return veh;
889 }
890 }
891 }
892 return nullptr;
893}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6479
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5600
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2065
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1896
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1881
bool tracking_on
Definition: vehicle.h:1971
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6837 of file game.cpp.

6840{
6841 // get global area info according to look_around caret position
6842 // TODO: fix point types
6844 lp ) ) ) );
6845 // we only need the area name and then pass it to print_all_tile_info() function below
6846 const std::string area_name = cur_ter_m->get_name();
6847 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6848}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6017
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:209

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6017 of file game.cpp.

6022{
6023 visibility_type visibility = VIS_HIDDEN;
6024 const bool inbounds = m.inbounds( lp );
6025 if( inbounds ) {
6026 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
6027 }
6028 const Creature *creature = critter_at( lp, true );
6029 switch( visibility ) {
6030 case VIS_CLEAR: {
6031 const optional_vpart_position vp = m.veh_at( lp );
6032 print_terrain_info( lp, w_look, area_name, column, line );
6033 print_fields_info( lp, w_look, column, line );
6034 print_trap_info( lp, w_look, column, line );
6035 print_creature_info( creature, w_look, column, line, last_line );
6036 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
6037 last_line );
6038 print_items_info( lp, w_look, column, line, last_line );
6039 print_graffiti_info( lp, w_look, column, line, last_line );
6040 }
6041 break;
6042 case VIS_BOOMER:
6043 case VIS_BOOMER_DARK:
6044 case VIS_DARK:
6045 case VIS_LIT:
6046 case VIS_HIDDEN:
6047 print_visibility_info( w_look, column, line, visibility );
6048
6049 if( creature != nullptr ) {
6050 std::vector<std::string> buf;
6051 if( u.sees_with_infrared( *creature ) ) {
6052 creature->describe_infrared( buf );
6053 } else if( u.sees_with_specials( *creature ) ) {
6054 creature->describe_specials( buf );
6055 }
6056 for( const std::string &s : buf ) {
6057 mvwprintw( w_look, point( 1, ++line ), s );
6058 }
6059 }
6060 break;
6061 }
6062 if( !inbounds ) {
6063 return;
6064 }
6065 auto this_sound = sounds::sound_at( lp );
6066 if( !this_sound.empty() ) {
6067 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
6068 } else {
6069 // Check other z-levels
6070 tripoint tmp = lp;
6071 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
6072 if( tmp.z == lp.z ) {
6073 continue;
6074 }
6075
6076 auto zlev_sound = sounds::sound_at( tmp );
6077 if( !zlev_sound.empty() ) {
6078 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
6079 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
6080 }
6081 }
6082 }
6083}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6436
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6187
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:6114
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6279
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6224
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6233
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6242
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:6085
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6205
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6455
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6224 of file game.cpp.

6226{
6227 int vLines = last_line - line;
6228 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
6229 line = creature->print_info( w_look, ++line, vLines, column );
6230 }
6231}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6187 of file game.cpp.

6189{
6190 const field &tmpfield = m.field_at( lp );
6191 for( auto &fld : tmpfield ) {
6192 const field_entry &cur = fld.second;
6193 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
6194 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
6195 const int max_width = getmaxx( w_look ) - column - 2;
6196 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
6197 get_fire_fuel_string( lp ) ) - 1;
6198 line += lines;
6199 } else {
6200 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
6201 }
6202 }
6203}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6279 of file game.cpp.

6282{
6283 if( line > last_line ) {
6284 return;
6285 }
6286
6287 const int max_width = getmaxx( w_look ) - column - 2;
6288 if( m.has_graffiti_at( lp ) ) {
6289 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6290 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6291 m.graffiti_at( lp ) );
6292 }
6293}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6242 of file game.cpp.

6245{
6246 if( !m.sees_some_items( lp, u ) ) {
6247 return;
6248 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6249 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6250 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6251 mvwprintz( w_look, point( column, ++line ), c_yellow,
6252 _( "There's something there, but you can't see what it is." ) );
6253 return;
6254 } else {
6255 std::map<std::string, int> item_names;
6256 for( auto &item : m.i_at( lp ) ) {
6257 ++item_names[item.tname()];
6258 }
6259
6260 const int max_width = getmaxx( w_look ) - column - 1;
6261 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6262 // last line but not last item
6263 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6264 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6265 break;
6266 }
6267
6268 if( it->second > 1 ) {
6269 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6270 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6271 it->first.c_str(), it->second );
6272 } else {
6273 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6274 }
6275 }
6276 }
6277}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4726
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 6114 of file game.cpp.

6117{
6118 const int max_width = getmaxx( w_look ) - column - 1;
6119 int lines;
6120
6121 const auto fmt_tile_info = []( const tripoint & lp ) {
6122 map &here = get_map();
6123 std::string ret;
6124 if( debug_mode ) {
6125 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
6126 if( here.has_furn( lp ) ) {
6127 ret += "; " + here.furn( lp )->id.str();
6128 }
6129 } else {
6130 ret = here.tername( lp );
6131 if( here.has_furn( lp ) ) {
6132 ret += "; " + here.furnname( lp );
6133 }
6134 }
6135 return ret;
6136 };
6137
6138 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
6139
6140 if( m.impassable( lp ) ) {
6141 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6142 _( "%s; Impassable" ),
6143 tile );
6144 } else {
6145 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6146 _( "%s; Movement cost %d" ),
6147 tile, m.move_cost( lp ) * 50 );
6148
6149 const auto ll = get_light_level( std::max( 1.0,
6150 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
6151 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
6152 wprintz( w_look, ll.second, ll.first );
6153 }
6154
6155 std::string signage = m.get_signage( lp );
6156 if( !signage.empty() ) {
6157 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6158 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
6159 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
6160 }
6161
6162 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
6163 // Print info about stuff below
6164 tripoint below( lp.xy(), lp.z - 1 );
6165 std::string tile_below = fmt_tile_info( below );
6166
6167 if( !m.has_floor_or_support( lp ) ) {
6168 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6169 _( "Below: %s; No support" ),
6170 tile_below );
6171 } else {
6172 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6173 _( "Below: %s; Walkable" ),
6174 tile_below );
6175 }
6176 }
6177
6178 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6179 m.features( lp ) );
6180 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
6181 m.coverage( lp ) );
6182 if( line < lines ) {
6183 line = lines + map_features - 1;
6184 }
6185}
Manage and cache data about a part of the map.
Definition: map.h:372
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2034
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:615
std::string features(const tripoint &p)
Definition: map.cpp:1709
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6210
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:490
ter_str_id id
Definition: mapdata.h:458

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6205 of file game.cpp.

6207{
6208 const trap &tr = m.tr_at( lp );
6209 if( tr.can_see( lp, u ) ) {
6210 partial_con *pc = m.partial_con_at( lp );
6211 std::string tr_name;
6212 if( pc && tr.loadid == tr_unfinished_construction ) {
6213 const construction &built = pc->id.obj();
6214 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.description,
6215 pc->counter / 100000 );
6216 } else {
6217 tr_name = tr.name();
6218 }
6219
6220 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
6221 }
6222}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5131
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string description
Definition: construction.h:51
construction_id id
Definition: construction.h:33
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::description, partial_con::id, line(), trap::loadid, m, mvwprintz(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6233 of file game.cpp.

6235{
6236 if( veh ) {
6237 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6238 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6239 }
6240}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 6085 of file game.cpp.

6087{
6088 const char *visibility_message = nullptr;
6089 switch( visibility ) {
6090 case VIS_CLEAR:
6091 visibility_message = _( "Clearly visible." );
6092 break;
6093 case VIS_BOOMER:
6094 visibility_message = _( "A bright pink blur." );
6095 break;
6096 case VIS_BOOMER_DARK:
6097 visibility_message = _( "A pink blur." );
6098 break;
6099 case VIS_DARK:
6100 visibility_message = _( "Darkness." );
6101 break;
6102 case VIS_LIT:
6103 visibility_message = _( "Bright light." );
6104 break;
6105 case VIS_HIDDEN:
6106 visibility_message = _( "Unseen." );
6107 break;
6108 }
6109
6110 mvwprintw( w_look, point( line, column ), visibility_message );
6111 line += 2;
6112}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1740 of file game.cpp.

1741{
1742 if( !u.activity ) {
1743 return;
1744 }
1745
1746 while( u.moves > 0 && u.activity ) {
1747 u.activity.do_turn( u );
1748 }
1749}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11854 of file game.cpp.

11855{
11856 const bool worn = p.is_worn( it );
11857 const bool wielded = ( &it == &p.weapon );
11858 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11859 if( worn ) {
11860 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11861 effects.insert( effects.end(), ew.begin(), ew.end() );
11862 }
11863 if( wielded ) {
11864 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11865 effects.insert( effects.end(), ew.begin(), ew.end() );
11866 }
11867
11868 if( it.is_tool() ) {
11869 // Recharge it if necessary
11870 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11871 //Before incrementing charge, check that any extra requirements are met
11872 if( check_art_charge_req( it ) ) {
11873 switch( it.type->artifact->charge_type ) {
11874 case ARTC_NULL:
11875 case NUM_ARTCS:
11876 break; // dummy entries
11877 case ARTC_TIME:
11878 // Once per hour
11879 if( calendar::once_every( 1_hours ) ) {
11880 it.charges++;
11881 }
11882 break;
11883 case ARTC_SOLAR:
11884 if( calendar::once_every( 10_minutes ) &&
11885 is_in_sunlight( p.pos() ) ) {
11886 it.charges++;
11887 }
11888 break;
11889 // Artifacts can inflict pain even on Deadened folks.
11890 // Some weird Lovecraftian thing. ;P
11891 // (So DON'T route them through mod_pain!)
11892 case ARTC_PAIN:
11893 if( calendar::once_every( 1_minutes ) ) {
11894 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11895 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11896 it.charges++;
11897 }
11898 break;
11899 case ARTC_HP:
11900 if( calendar::once_every( 1_minutes ) ) {
11901 add_msg( m_bad, _( "You feel your body decaying." ) );
11902 p.hurtall( 1, nullptr );
11903 it.charges++;
11904 }
11905 break;
11906 case ARTC_FATIGUE:
11907 if( calendar::once_every( 1_minutes ) ) {
11908 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11909 u.mod_fatigue( 3 * rng( 1, 3 ) );
11910 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11911 it.charges++;
11912 }
11913 break;
11914 // Portals are energetic enough to charge the item.
11915 // Tears in reality are consumed too, but can't charge it.
11916 case ARTC_PORTAL:
11917 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11918 m.remove_field( dest, fd_fatigue );
11919 if( m.tr_at( dest ).loadid == tr_portal ) {
11920 add_msg( m_good, _( "The portal collapses!" ) );
11921 m.remove_trap( dest );
11922 it.charges++;
11923 break;
11924 }
11925 }
11926 break;
11927 }
11928 }
11929 }
11930 }
11931
11932 for( const art_effect_passive &i : effects ) {
11933 switch( i ) {
11934 case AEP_STR_UP:
11935 p.mod_str_bonus( +4 );
11936 break;
11937 case AEP_DEX_UP:
11938 p.mod_dex_bonus( +4 );
11939 break;
11940 case AEP_PER_UP:
11941 p.mod_per_bonus( +4 );
11942 break;
11943 case AEP_INT_UP:
11944 p.mod_int_bonus( +4 );
11945 break;
11946 case AEP_ALL_UP:
11947 p.mod_str_bonus( +2 );
11948 p.mod_dex_bonus( +2 );
11949 p.mod_per_bonus( +2 );
11950 p.mod_int_bonus( +2 );
11951 break;
11952 case AEP_SPEED_UP:
11953 // Handled in player::current_speed()
11954 break;
11955
11956 case AEP_PBLUE:
11957 if( p.get_rad() > 0 ) {
11958 p.mod_rad( -1 );
11959 }
11960 break;
11961
11962 case AEP_SMOKE:
11963 if( one_in( 10 ) ) {
11964 tripoint pt( p.posx() + rng( -1, 1 ),
11965 p.posy() + rng( -1, 1 ),
11966 p.posz() );
11967 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11968 }
11969 break;
11970
11971 case AEP_SNAKES:
11972 break; // Handled in player::hit()
11973
11974 case AEP_EXTINGUISH:
11975 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11976 m.mod_field_age( dest, fd_fire, -1_turns );
11977 }
11978 break;
11979
11980 case AEP_FUN:
11981 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11982 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11983 break;
11984
11985 case AEP_HUNGER:
11986 if( one_in( 100 ) ) {
11987 p.mod_stored_kcal( -10 );
11988 }
11989 break;
11990
11991 case AEP_THIRST:
11992 if( one_in( 120 ) ) {
11993 p.mod_thirst( 1 );
11994 }
11995 break;
11996
11997 case AEP_EVIL:
11998 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11999 p.add_effect( effect_evil, 30_minutes );
12000 if( it.is_armor() ) {
12001 if( !worn ) {
12002 add_msg( _( "You have an urge to wear the %s." ),
12003 it.tname() );
12004 }
12005 } else if( !wielded ) {
12006 add_msg( _( "You have an urge to wield the %s." ),
12007 it.tname() );
12008 }
12009 }
12010 break;
12011
12012 case AEP_SCHIZO:
12013 break; // Handled in player::suffer()
12014
12015 case AEP_RADIOACTIVE:
12016 if( one_in( 4 ) ) {
12017 p.irradiate( 1.0f );
12018 }
12019 break;
12020
12021 case AEP_STR_DOWN:
12022 p.mod_str_bonus( -3 );
12023 break;
12024
12025 case AEP_DEX_DOWN:
12026 p.mod_dex_bonus( -3 );
12027 break;
12028
12029 case AEP_PER_DOWN:
12030 p.mod_per_bonus( -3 );
12031 break;
12032
12033 case AEP_INT_DOWN:
12034 p.mod_int_bonus( -3 );
12035 break;
12036
12037 case AEP_ALL_DOWN:
12038 p.mod_str_bonus( -2 );
12039 p.mod_dex_bonus( -2 );
12040 p.mod_per_bonus( -2 );
12041 p.mod_int_bonus( -2 );
12042 break;
12043
12044 case AEP_SPEED_DOWN:
12045 break; // Handled in player::current_speed()
12046
12047 default:
12048 //Suppress warnings
12049 break;
12050 }
12051 }
12052 // Recalculate, as it might have changed (by mod_*_bonus above)
12053 p.str_cur = p.get_str();
12054 p.int_cur = p.get_int();
12055 p.dex_cur = p.get_dex();
12056 p.per_cur = p.get_per();
12057}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4196
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4191
int str_cur
Definition: character.h:304
void mod_rad(int mod)
Definition: character.cpp:7196
virtual int get_dex() const
Definition: character.cpp:4080
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4311
bool is_worn(const item &thing) const
Definition: character.h:1142
virtual int get_int() const
Definition: character.cpp:4088
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4442
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4186
int int_cur
Definition: character.h:306
int get_rad() const
Definition: character.cpp:7186
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9101
virtual int get_per() const
Definition: character.cpp:4084
void mod_stamina(int mod)
Definition: character.cpp:7223
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8667
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1532
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4201
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1349
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:5157
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7215
bool is_tool() const
Definition: item.cpp:6792
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7242
int charges
Definition: item.h:2195
bool is_armor() const
Definition: item.cpp:6543
const itype * type
Definition: item.h:2156
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5386
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5306
void remove_trap(const tripoint &p)
Definition: map.cpp:5251
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:864

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1701 of file game.cpp.

1702{
1703 if( u.has_effect( effect_sleep ) ) {
1704 // Can't interrupt
1705 return;
1706 }
1707
1708 bool has_activity = u.activity && u.activity.moves_left > 0;
1709 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1710
1711 if( !has_activity && !is_travelling ) {
1712 // Nohing to interrupt
1713 return;
1714 }
1715
1716 // Key poll may be quite expensive, so limit it to 10 times per second.
1717 static auto last_poll = std::chrono::steady_clock::now();
1718 auto now = std::chrono::steady_clock::now();
1719 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1720 ( now - last_poll ).count();
1721
1722 if( difference > 100 ) {
1724 last_poll = now;
1725 }
1726
1727 // If player is performing a task and a monster is dangerously close, warn them
1728 // regardless of previous safemode warnings
1729 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1731 Creature *hostile_critter = is_hostile_very_close();
1732 if( hostile_critter != nullptr ) {
1734 string_format( _( "The %s is dangerously close!" ),
1735 hostile_critter->get_name() ) );
1736 }
1737 }
1738}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9232
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2055
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9254 of file game.cpp.

9255{
9256 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9257
9258 if( !harmful_stuff.empty() &&
9259 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
9260 return false;
9261 }
9262 if( !harmful_stuff.empty() && u.is_mounted() &&
9263 m.tr_at( dest_loc ).loadid == tr_ledge ) {
9264 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
9265 u.mounted_creature->get_name() );
9266 return false;
9267 }
9268 return true;
9269}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11822 of file game.cpp.

11823{
11824 const WORLDPTR active_world = world_generator->active_world;
11825 if( active_world == nullptr ) {
11826 return;
11827 }
11828
11829 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11830 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11831 MAPBUFFER.reset();
11833 try {
11834 setup();
11835 } catch( const std::exception &err ) {
11836 debugmsg( "Error: %s", err.what() );
11837 }
11839 }
11840 } else {
11841 popup_getkey( _( "No saves for %s yet." ), u.name );
11842 }
11843}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2831
void setup()
Definition: game.cpp:558
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11800 of file game.cpp.

11801{
11802 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11803 if( !moves_since_last_save ) {
11804 return;
11805 }
11806 add_msg( m_info, _( "Saving game, this may take a while" ) );
11807
11809 popup.message( "%s", _( "Saving game, this may take a while" ) );
11812
11813 time_t now = time( nullptr ); //timestamp for start of saving procedure
11814
11815 //perform save
11816 save();
11817 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11819 last_save_timestamp = now;
11820}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 546 of file game.cpp.

547{
548 if( was_fullscreen ) {
549 if( !fullscreen ) {
551 }
552 }
553}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload()

void game::reload ( item_location loc,
bool  prompt = false,
bool  empty = true 
)

Definition at line 8844 of file game.cpp.

8845{
8847 item *it = loc.get_item();
8848
8849 // bows etc. do not need to reload. select favorite ammo for them instead
8850 if( it->has_flag( "RELOAD_AND_SHOOT" ) ) {
8852 return;
8853 }
8854
8855 switch( u.rate_action_reload( *it ) ) {
8856 case hint_rating::iffy:
8857 if( ( it->is_ammo_container() || it->is_magazine() ) && it->ammo_remaining() > 0 &&
8858 it->ammo_remaining() == it->ammo_capacity() ) {
8859 add_msg( m_info, _( "The %s is already fully loaded!" ), it->tname() );
8860 return;
8861 }
8862 if( it->is_ammo_belt() ) {
8863 const auto &linkage = it->type->magazine->linkage;
8864 if( linkage && !u.has_charges( *linkage, 1 ) ) {
8865 add_msg( m_info, _( "You need at least one %s to reload the %s!" ),
8866 item::nname( *linkage, 1 ), it->tname() );
8867 return;
8868 }
8869 }
8870 if( it->is_watertight_container() && it->is_container_full() ) {
8871 add_msg( m_info, _( "The %s is already full!" ), it->tname() );
8872 return;
8873 }
8874
8875 // intentional fall-through
8876
8877 case hint_rating::cant:
8878 add_msg( m_info, _( "You can't reload a %s!" ), it->tname() );
8879 return;
8880
8881 case hint_rating::good:
8882 break;
8883 }
8884
8885 bool use_loc = true;
8886 if( !it->has_flag( "ALLOWS_REMOTE_USE" ) ) {
8887 it = loc.obtain( u ).get_item();
8888 use_loc = false;
8889 }
8890
8891 // for holsters and ammo pouches try to reload any contained item
8892 if( it->type->can_use( "holster" ) && !it->contents.empty() ) {
8893 it = &it->contents.front();
8894 }
8895
8896 // for bandoliers we currently defer to iuse_actor methods
8897 if( it->is_bandolier() ) {
8898 auto ptr = dynamic_cast<const bandolier_actor *>
8899 ( it->type->get_use( "bandolier" )->get_actor_ptr() );
8900 ptr->reload( u, *it );
8901 return;
8902 }
8903
8905
8906 if( opt.ammo.get_item() == nullptr ) {
8907 return;
8908 }
8909
8910 if( opt ) {
8911 int moves = opt.moves();
8912 if( it->get_var( "dirt", 0 ) > 7800 ) {
8913 add_msg( m_warning, _( "You struggle to reload the fouled %s." ), it->tname() );
8914 moves += 2500;
8915 }
8916
8917 u.assign_activity( activity_id( "ACT_RELOAD" ), moves, opt.qty() );
8918 if( use_loc ) {
8919 u.activity.targets.emplace_back( loc );
8920 } else {
8921 u.activity.targets.emplace_back( u, const_cast<item *>( opt.target ) );
8922 }
8923 u.activity.targets.push_back( std::move( opt.ammo ) );
8924 }
8925}
bool has_charges(const itype_id &it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >) const
Definition: character.cpp:9608
Store ammo and later reload using it.
Definition: iuse_actor.h:885
int moves() const
Definition: item.cpp:7865
const item * target
Definition: item.h:482
int qty() const
Definition: item.h:485
item_location ammo
Definition: item.h:483
item & front()
this is an artifact of the previous code using front() everywhere for contents.
bool empty() const
item * get_item()
Gets the selected item or nullptr.
item_location obtain(Character &ch, int qty=-1)
Move an item from the location to the character inventory.
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1021
bool is_ammo_container() const
Definition: item.cpp:6501
bool is_watertight_container() const
Whether this is a container which can be used to store liquids.
Definition: item.cpp:6563
static std::string nname(const itype_id &id, unsigned int quantity=1)
Returns the translated item name for the item with given id.
Definition: item.cpp:9738
bool is_ammo_belt() const
Definition: item.cpp:6406
item_contents contents
Definition: item.h:2157
bool is_container_full(bool allow_bucket=false) const
Whether this item has no more free capacity for its current content.
Definition: item.cpp:6681
bool is_bandolier() const
Definition: item.cpp:6411
bool has_flag(const std::string &flag) const
Definition: item.cpp:5181
bool is_magazine() const
Definition: item.cpp:6396
item_location ammo_location
Definition: player.h:693
const void * ptr(const T *p)
\rst Converts p to const void* for pointer formatting.
static item::reload_option favorite_ammo_or_select(const player &u, const item &it, bool empty, bool prompt)
Definition: game.cpp:8825
@ prompt
Definition: pickup.h:30
const use_function * get_use(const std::string &iuse_name) const
Definition: itype.cpp:91
cata::value_ptr< islot_magazine > magazine
Definition: itype.h:859
bool can_use(const std::string &iuse_name) const
Definition: itype.cpp:86

References _, Character::activity, add_msg(), item::reload_option::ammo, item::ammo_capacity(), player::ammo_location, item::ammo_remaining(), Character::assign_activity(), itype::can_use(), cant, item::contents, item_contents::empty(), favorite_ammo_or_select(), item_contents::front(), use_function::get_actor_ptr(), item_location::get_item(), itype::get_use(), item::get_var(), good, Character::has_charges(), item::has_flag(), iffy, item::is_ammo_belt(), item::is_ammo_container(), item::is_bandolier(), item::is_container_full(), item::is_magazine(), item::is_watertight_container(), m_info, m_warning, itype::magazine, item_location::make_dirty(), avatar_action::move(), item::reload_option::moves(), item::nname(), item_location::obtain(), pickup::prompt, ranged::prompt_select_default_ammo_for(), ptr(), item::reload_option::qty(), player::rate_action_reload(), item::reload_option::target, player_activity::targets, item::tname(), item::type, and u.

Referenced by inventory_item_menu(), reload_item(), and reload_wielded().

◆ reload_item()

void game::reload_item ( )

Definition at line 8928 of file game.cpp.

8929{
8930 item_location item_loc = inv_map_splice( [&]( const item & it ) {
8931 return u.rate_action_reload( it ) == hint_rating::good;
8932 }, _( "Reload item" ), 1, _( "You have nothing to reload." ) );
8933
8934 if( !item_loc ) {
8935 add_msg( _( "Never mind." ) );
8936 return;
8937 }
8938
8939 reload( item_loc );
8940}
item_location inv_map_splice(item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
Custom-filtered menu for inventory and nearby items and those that within specified radius.

References _, add_msg(), good, inv_map_splice(), player::rate_action_reload(), reload(), and u.

Referenced by handle_action().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 958 of file game.cpp.

959{
960 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
961 // and not invoke "on_load" for those NPCs that avoided unloading this way.
962 unload_npcs();
963 load_npcs();
964}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 519 of file game.cpp.

520{
521#if defined(TILES)
522 try {
523 tilecontext->reinit();
524 tilecontext->load_tileset( get_option<std::string>( "TILES" ), false, true );
525 tilecontext->do_tile_loading_report();
526 } catch( const std::exception &err ) {
527 popup( _( "Loading the tileset failed: %s" ), err.what() );
528 }
529 g->reset_zoom();
530 g->mark_main_ui_adaptor_resize();
531#endif // TILES
532}

References _, g, and popup().

Referenced by handle_action().

◆ reload_weapon()

void game::reload_weapon ( bool  try_everything = true)

Definition at line 8952 of file game.cpp.

8953{
8954 // As a special streamlined activity, hitting reload repeatedly should:
8955 // Reload wielded gun
8956 // First reload a magazine if necessary.
8957 // Then load said magazine into gun.
8958 // Reload magazines that are compatible with the current gun.
8959 // Reload other guns in inventory.
8960 // Reload misc magazines in inventory.
8961 std::vector<item_location> reloadables = u.find_reloadables();
8962 std::sort( reloadables.begin(), reloadables.end(),
8963 [this]( const item_location & a, const item_location & b ) {
8964 const item *ap = a.get_item();
8965 const item *bp = b.get_item();
8966 // Current wielded weapon comes first.
8967 if( this->u.is_wielding( *bp ) ) {
8968 return false;
8969 }
8970 if( this->u.is_wielding( *ap ) ) {
8971 return true;
8972 }
8973 // Second sort by affiliation with wielded gun
8974 const std::set<itype_id> compatible_magazines = this->u.weapon.magazine_compatible();
8975 const bool mag_ap = compatible_magazines.count( ap->typeId() ) > 0;
8976 const bool mag_bp = compatible_magazines.count( bp->typeId() ) > 0;
8977 if( mag_ap != mag_bp ) {
8978 return mag_ap;
8979 }
8980 // Third sort by gun vs magazine,
8981 if( ap->is_gun() != bp->is_gun() ) {
8982 return ap->is_gun();
8983 }
8984 // Finally sort by speed to reload.
8985 return ( ap->get_reload_time() * ( ap->ammo_capacity() - ap->ammo_remaining() ) ) <
8986 ( bp->get_reload_time() * ( bp->ammo_capacity() - bp->ammo_remaining() ) );
8987 } );
8988 for( item_location &candidate : reloadables ) {
8989 std::vector<item::reload_option> ammo_list;
8990 u.list_ammo( *candidate.get_item(), ammo_list, false );
8991 if( !ammo_list.empty() ) {
8992 reload( candidate, false, false );
8993 return;
8994 }
8995 }
8996 // Just for testing, bail out here to avoid unwanted side effects.
8997 if( !try_everything ) {
8998 return;
8999 }
9000 // If we make it here and haven't found anything to reload, start looking elsewhere.
9001 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
9002 turret_data turret;
9003 if( veh && ( turret = veh->turret_query( u.pos() ) ) && turret.can_reload() ) {
9004 item::reload_option opt = g->u.select_ammo( *turret.base(), true );
9005 if( opt ) {
9006 g->u.assign_activity( activity_id( "ACT_RELOAD" ), opt.moves(), opt.qty() );
9007 g->u.activity.targets.emplace_back( turret.base() );
9008 g->u.activity.targets.push_back( std::move( opt.ammo ) );
9009 }
9010 return;
9011 }
9012
9013 reload_item();
9014}
std::vector< item_location > find_reloadables()
Searches for weapons and magazines that can be reloaded.
Definition: character.cpp:2692
bool list_ammo(const item &base, std::vector< item::reload_option > &ammo_list, bool include_empty_mags=true, bool include_potential=false) const
Definition: player.cpp:2389
bool can_reload() const
Definition: turret.cpp:212
item_location base()
Get base item location.
Definition: turret.cpp:84
turret_data turret_query(vehicle_part &pt)
Get firing data for a turret.
Definition: turret.cpp:55
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031

References a, b, Character::find_reloadables(), and u.

Referenced by handle_action().

◆ reload_wielded()

void game::reload_wielded ( bool  prompt = false)

Definition at line 8942 of file game.cpp.

8943{
8944 if( u.weapon.is_null() || !u.weapon.is_reloadable() ) {
8945 add_msg( _( "You aren't holding something you can reload." ) );
8946 return;
8947 }
8948 item_location item_loc = item_location( u, &u.weapon );
8949 reload( item_loc, prompt );
8950}
bool is_null() const
Definition: item.cpp:728
bool is_reloadable() const
Is it ever possible to reload this item? Only the base item is considered with any mods ignored.
Definition: item.cpp:9646

References _, add_msg(), item::is_null(), item::is_reloadable(), pickup::prompt, reload(), u, and Character::weapon.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2572 of file game.cpp.

2573{
2575 return remoteveh_cache;
2576 }
2578 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2579 if( remote_veh_string.str().empty() ||
2581 remoteveh_cache = nullptr;
2582 } else {
2583 tripoint vp;
2584 remote_veh_string >> vp.x >> vp.y >> vp.z;
2585 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2586 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2587 remoteveh_cache = veh;
2588 } else {
2589 remoteveh_cache = nullptr;
2590 }
2591 }
2592 return remoteveh_cache;
2593}
vehicle * remoteveh_cache
Definition: game.h:1093
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3182
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1964 of file game.cpp.

1965{
1966 follower_ids.erase( id );
1967 u.follower_ids.erase( id );
1968}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 5036 of file game.cpp.

5037{
5038 critter_tracker->remove( critter );
5039}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 11320 of file game.cpp.

11321{
11322 for( auto &elem : coming_to_stairs ) {
11323 elem.staircount = 0;
11324 const tripoint pnt( elem.pos().xy(), get_levz() );
11325 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
11326 }
11327
11328 coming_to_stairs.clear();
11329}
std::vector< monster > coming_to_stairs
Definition: game.h:1031

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7426 of file game.cpp.

7427{
7428 const int width = getmaxx( window );
7429 for( int i = 1; i < TERMX; i++ ) {
7430 if( i < width ) {
7431 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7432 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7433 LINE_OXOX ); // -
7434 }
7435
7436 if( i < TERMY - height ) {
7437 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7438 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7439 }
7440 }
7441
7442 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7443 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7444
7445 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7446 LINE_XXXO ); // |-
7447 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7448 LINE_XOXX ); // -|
7449
7450 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7451 wprintz( window, c_white, _( "Items" ) );
7452
7453 std::string sSort;
7454 if( bRadiusSort ) {
7455 //~ Sort type: distance.
7456 sSort = _( "<s>ort: dist" );
7457 } else {
7458 //~ Sort type: category.
7459 sSort = _( "<s>ort: cat" );
7460 }
7461
7462 int letters = utf8_width( sSort );
7463
7464 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7465
7466 std::vector<std::string> tokens;
7467 if( !sFilter.empty() ) {
7468 tokens.emplace_back( _( "<R>eset" ) );
7469 }
7470
7471 tokens.emplace_back( _( "<E>xamine" ) );
7472 tokens.emplace_back( _( "<C>ompare" ) );
7473 tokens.emplace_back( _( "<F>ilter" ) );
7474 tokens.emplace_back( _( "<+/->Priority" ) );
7475
7476 int gaps = tokens.size() + 1;
7477 letters = 0;
7478 int n = tokens.size();
7479 for( int i = 0; i < n; i++ ) {
7480 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7481 }
7482
7483 int usedwidth = letters;
7484 const int gap_spaces = ( width - usedwidth ) / gaps;
7485 usedwidth += gap_spaces * gaps;
7486 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7487
7488 for( int i = 0; i < n; i++ ) {
7489 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7490 tokens[i] ) + gap_spaces;
7491 }
7492}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3933 of file game.cpp.

3934{
3935 for( float &lev : latest_lightlevels ) {
3936 lev = -std::numeric_limits<float>::max();
3937 }
3938}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 3008 of file game.cpp.

3009{
3010 for( auto elem : follower_ids ) {
3011 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
3012 if( !npc_to_get ) {
3013 continue;
3014 }
3015 npc *npc_to_add = npc_to_get.get();
3016 npc_to_add->chatbin.missions.clear();
3017 npc_to_add->chatbin.missions_assigned.clear();
3018 npc_to_add->mission = NPC_MISSION_NULL;
3019 npc_to_add->chatbin.mission_selected = nullptr;
3020 npc_to_add->set_attitude( NPCATT_NULL );
3021 npc_to_add->op_of_u.anger = 0;
3022 npc_to_add->op_of_u.fear = 0;
3023 npc_to_add->op_of_u.trust = 0;
3024 npc_to_add->op_of_u.value = 0;
3025 npc_to_add->op_of_u.owed = 0;
3026 npc_to_add->set_fac( faction_id( "no_faction" ) );
3028 npc_to_add->global_omt_location(),
3029 npc_to_add->getID() ) );
3030
3031 }
3032
3033}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3141
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2637
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:465
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7341 of file game.cpp.

7342{
7343#if defined(TILES)
7345 rescale_tileset( tileset_zoom );
7346#endif // TILES
7347}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 5167 of file game.cpp.

5168{
5169 if( !it.is_corpse() ) {
5170 debugmsg( "Tried to revive a non-corpse." );
5171 return false;
5172 }
5173 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
5174 ( it.get_mtype()->id );
5175 monster &critter = *newmon_ptr;
5176 critter.init_from_item( it );
5177 if( critter.get_hp() < 1 ) {
5178 // Failed reanimation due to corpse being too burned
5179 return false;
5180 }
5181 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
5182 it.has_flag( "QUARTERED" ) ) {
5183 // Failed reanimation due to corpse being butchered
5184 return false;
5185 }
5186
5187 critter.no_extra_death_drops = true;
5188 critter.add_effect( effect_downed, 5_turns, num_bp );
5189 for( const item &component : it.components ) {
5190 critter.corpse_components.push_back( component );
5191 }
5192
5193 if( it.get_var( "zlave" ) == "zlave" ) {
5194 critter.add_effect( effect_pacified, 1_turns, num_bp );
5195 critter.add_effect( effect_pet, 1_turns, num_bp );
5196 }
5197
5198 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
5199 for( auto &ammo : critter.ammo ) {
5200 ammo.second = 0;
5201 }
5202 }
5203
5204 return place_critter_at( newmon_ptr, p );
5205}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4964
const mtype * get_mtype() const
Definition: item.cpp:6464
std::list< item > components
Definition: item.h:2158
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6459
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2894
bool no_extra_death_drops
Definition: monster.h:480
std::vector< item > corpse_components
Definition: monster.h:457
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2758
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 3109 of file game.cpp.

3110{
3111 try {
3112 if( !save_player_data() ||
3114 !save_artifacts() ||
3115 !save_maps() ||
3116 !get_auto_pickup().save_character() ||
3118 !get_safemode().save_character() ||
3119 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
3120 JsonOut jsout( fout );
3121 uistate.serialize( jsout );
3122 }, _( "uistate data" ) ) ) {
3123 return false;
3124 } else {
3125 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
3126 return true;
3127 }
3128 } catch( std::ios::failure &err ) {
3129 popup( _( "Failed to save game data" ) );
3130 return false;
3131 }
3132}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:3063
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 3044 of file game.cpp.

3045{
3046 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
3047 return ::save_artifacts( artfilename );
3048}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5207 of file game.cpp.

5208{
5209 int assist_bonus = installer.get_effect_int( effect_assisted );
5210
5211 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
5214 -1 );
5215
5216 int damage = cyborg->damage();
5217 int dmg_lvl = cyborg->damage_level( 4 );
5218 int difficulty = 12;
5219
5220 if( damage != 0 ) {
5221
5222 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
5223 dmg_lvl );
5224
5225 // Damage of the cyborg increases difficulty
5226 difficulty += dmg_lvl;
5227 }
5228
5229 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
5230 int success = chance_of_success - rng( 1, 100 );
5231
5232 if( !g->u.query_yn(
5233 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5234 100 - static_cast<int>( chance_of_success ) ) ) {
5235 return;
5236 }
5237
5238 if( success > 0 ) {
5239 add_msg( m_good, _( "Successfully removed Personality override." ) );
5240 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5241
5242 m.i_rem( couch_pos, cyborg );
5243
5244 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5245 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5246 tmp->normalize();
5247 tmp->load_npc_template( npc_cyborg );
5248 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5250 tmp->hurtall( dmg_lvl * 10, nullptr );
5251 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5252 load_npcs();
5253
5254 } else {
5255 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5256 adjusted_skill ) );
5257 const int fail_type = std::min( 5, failure_level );
5258 switch( fail_type ) {
5259 case 1:
5260 case 2:
5261 add_msg( m_info, _( "The removal fails." ) );
5262 add_msg( m_bad, _( "The body is damaged." ) );
5263 cyborg->set_damage( damage + 1000 );
5264 break;
5265 case 3:
5266 case 4:
5267 add_msg( m_info, _( "The removal fails badly." ) );
5268 add_msg( m_bad, _( "The body is badly damaged!" ) );
5269 cyborg->set_damage( damage + 2000 );
5270 break;
5271 case 5:
5272 add_msg( m_info, _( "The removal is a catastrophe." ) );
5273 add_msg( m_bad, _( "The body is destroyed!" ) );
5274 m.i_rem( couch_pos, cyborg );
5275 break;
5276 default:
5277 break;
5278 }
5279
5280 }
5281
5282}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1888
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1845
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:710
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:697
int damage() const
How much damage has the item sustained?
Definition: item.cpp:692
map_stack::iterator i_rem(const tripoint &p, map_stack::const_iterator it)
Definition: map.cpp:4082
static const skill_id skill_computer("computer")
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 3036 of file game.cpp.

3037{
3038 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
3039 return write_to_file( masterfile, [&]( std::ostream & fout ) {
3040 serialize_master( fout );
3041 }, _( "factions data" ) );
3042}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1257

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 3050 of file game.cpp.

3051{
3052 try {
3053 m.save();
3054 overmap_buffer.save(); // can throw
3055 MAPBUFFER.save(); // can throw
3056 return true;
3057 } catch( const std::exception &err ) {
3058 popup( _( "Failed to save the maps: %s" ), err.what() );
3059 return false;
3060 }
3061}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 3063 of file game.cpp.

3064{
3065 const std::string playerfile = get_player_base_save_path();
3066
3067 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
3068 serialize( fout );
3069 }, _( "player data" ) );
3070 const bool saved_map_memory = u.save_map_memory();
3071 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
3072 std::ostream & fout ) {
3073 fout << memorial().dump();
3074 }, _( "player memorial" ) );
3075#if defined(__ANDROID__)
3076 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
3077 std::ostream & fout ) {
3078 save_shortcuts( fout );
3079 }, _( "quick shortcuts" ) );
3080#endif
3081
3082 return saved_data && saved_map_memory && saved_log
3083#if defined(__ANDROID__)
3084 && saved_shortcuts
3085#endif
3086 ;
3087}
bool save_map_memory()
Definition: avatar.cpp:127
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12537
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:1023
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1257 of file savegame.cpp.

1258{
1259 fout << "# version " << savegame_version << std::endl;
1260 try {
1261 JsonOut json( fout, true ); // pretty-print
1262 json.start_object();
1263
1264 json.member( "next_mission_id", next_mission_id );
1265 json.member( "next_npc_id", next_npc_id );
1266
1267 json.member( "active_missions" );
1268 mission::serialize_all( json );
1269
1270 json.member( "factions", *faction_manager_ptr );
1271 json.member( "seed", seed );
1272
1273 json.member( "weather" );
1274 json.start_object();
1275 json.member( "lightning", get_weather().lightning_active );
1276 json.end_object();
1277
1278 json.end_object();
1279 } catch( const JsonError &e ) {
1280 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1281 }
1282}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1248

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1872 of file game.cpp.

1873{
1874 critter_died = true;
1875}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1689 of file game.cpp.

1690{
1691 // remove the previous driving offset,
1692 // store the new offset and apply the new offset.
1699}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1867 of file game.cpp.

1868{
1869 npcs_dirty = true;
1870}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 9182 of file game.cpp.

9183{
9184 safe_mode = mode;
9186}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7349 of file game.cpp.

7350{
7351#if defined(TILES)
7352 if( tileset_zoom != level ) {
7353 tileset_zoom = level;
7354 rescale_tileset( tileset_zoom );
7355 }
7356#else
7357 static_cast<void>( level );
7358#endif // TILES
7359}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2595 of file game.cpp.

2596{
2598 remoteveh_cache = veh;
2599 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2601 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2602 veh = nullptr;
2603 }
2604
2605 if( veh == nullptr ) {
2606 u.remove_value( "remote_controlling_vehicle" );
2607 return;
2608 }
2609
2610 std::stringstream remote_veh_string;
2611 const tripoint vehpos = veh->global_pos3();
2612 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2613 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2614}
void remove_value(const std::string &key)
Definition: creature.cpp:1333

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 558 of file game.cpp.

559{
560 loading_ui ui( true );
561 {
564 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
567
569 }
570
572
573 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
574 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
575 }
576
577 m = map( get_option<bool>( "ZLEVELS" ) );
578
580 next_mission_id = 1;
581 new_game = true;
582 uquit = QUIT_NO; // We haven't quit the game
583 bVMonsterLookFire = true;
584
585 // invalidate calendar caches in case we were previously playing
586 // a different world
587 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
588 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
589
592
593 turnssincelastmon = 0; //Auto safe mode init
594
597 coming_to_stairs.clear();
598 active_npc.clear();
599 faction_manager_ptr->clear();
604
605 SCT.vSCT.clear(); //Delete pending messages
606
607 stats().clear();
608 // reset kill counts
609 kill_tracker_ptr->clear();
611 // reset follower list
612 follower_ids.clear();
613 scent.reset();
614
616 remoteveh_cache = nullptr;
617
618 token_provider_ptr->clear();
619 // back to menu for save loading, new game etc
620}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:5041
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2943
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4894 of file game.cpp.

4895{
4896 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4897 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4898 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4899 }
4900 if( critter.is_monster() ) {
4901 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4902 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4903 return std::dynamic_pointer_cast<T>( mon_ptr );
4904 }
4905 }
4906 }
4907 if( critter.is_npc() ) {
4908 for( auto &cur_npc : active_npc ) {
4909 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4910 return std::dynamic_pointer_cast<T>( cur_npc );
4911 }
4912 }
4913 }
4914 return nullptr;
4915}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12550 of file game.cpp.

12551{
12552 for( tripoint &p : destination_preview ) {
12553 p += delta;
12554 }
12555}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11555 of file game.cpp.

11556{
11557 // If either shift argument is non-zero, we're shifting.
11558 if( shift == tripoint_zero ) {
11559 return;
11560 }
11561 for( monster &critter : all_monsters() ) {
11562 if( shift.xy() != point_zero ) {
11563 critter.shift( shift.xy() );
11564 }
11565
11566 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11567 // We're inbounds, so don't despawn after all.
11568 // No need to shift Z-coordinates, they are absolute
11569 continue;
11570 }
11571 // Either a vertical shift or the critter is now outside of the reality bubble,
11572 // anyway: it must be saved and removed.
11573 despawn_monster( critter );
11574 }
11575 // The order in which zombies are shifted may cause zombies to briefly exist on
11576 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11577 critter_tracker->rebuild_cache();
11578}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12557 of file game.cpp.

12558{
12559 ///\EFFECT_DEX decreases chances of slipping while climbing
12560 int climb = u.dex_cur;
12561 if( u.has_trait( trait_BADKNEES ) ) {
12562 climb = climb / 2;
12563 }
12564 if( one_in( climb ) ) {
12565 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12566 if( climb <= 1 ) {
12567 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12568 }
12569 return true;
12570 }
12571 return false;
12572}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 5052 of file game.cpp.

5053{
5054 if( one_in( 100 ) ) {
5055 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5056 tmp->normalize();
5057 tmp->randomize( NC_HALLU );
5058 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
5059 if( !critter_at( p, true ) ) {
5061 load_npcs();
5062 return true;
5063 } else {
5064 return false;
5065 }
5066 }
5067
5069 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
5070 phantasm->hallucination = true;
5071 phantasm->spawn( p );
5072
5073 //Don't attempt to place phantasms inside of other creatures
5074 if( !critter_at( phantasm->pos(), true ) ) {
5075 return critter_tracker->add( phantasm );
5076 } else {
5077 return false;
5078 }
5079}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 3104 of file game.cpp.

3105{
3106 return *spell_events_ptr;
3107}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 12119 of file game.cpp.

12120{
12121 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
12122 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
12123 scen->has_flag( "SUM_ADV_START" );
12124
12126 if( scen_season ) {
12127 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
12129 get_option<int>( "INITIAL_TIME" );
12130 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
12131 if( scen->has_flag( "SPR_START" ) ) {
12133 } else if( scen->has_flag( "SUM_START" ) ) {
12136 } else if( scen->has_flag( "AUT_START" ) ) {
12139 } else if( scen->has_flag( "WIN_START" ) ) {
12142 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
12145 } else {
12146 debugmsg( "The Unicorn" );
12147 }
12148 } else {
12149 // No scenario, so use the starting date+time configured in world options
12150 int initial_days = get_option<int>( "INITIAL_DAY" );
12151 if( initial_days == -1 ) {
12152 // 0 - 363 for a 91 day season
12153 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
12154 }
12156
12157 // Determine the season based off how long the seasons are set to be
12158 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
12159 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
12160 if( season_number == 0 ) {
12162 } else if( season_number == 1 ) {
12164 } else if( season_number == 2 ) {
12166 } else {
12168 }
12169
12171 + 1_hours * get_option<int>( "INITIAL_TIME" )
12172 + 1_days * get_option<int>( "SPAWN_DELAY" );
12173 }
12174
12176}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1030
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 645 of file game.cpp.

646{
647 if( !gamemode ) {
648 gamemode = std::make_unique<special_game>();
649 }
650
651 seed = rng_bits();
652 new_game = true;
655 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
656 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
658
660
663 popup.message( "%s", _( "Please wait as we build your world" ) );
666
667 load_master();
668 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
669
673 do {
674 omtstart = start_loc.find_player_initial_location();
675 if( omtstart == overmap::invalid_tripoint ) {
676 if( query_yn(
677 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
680 } else {
681 return false;
682 }
683 }
684 } while( omtstart == overmap::invalid_tripoint );
685
686 start_loc.prepare_map( omtstart );
687
688 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
689 if( u.starting_vehicle &&
690 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
691 std::vector<std::string> {} ) ) {
692 debugmsg( "could not place starting vehicle" );
693 }
694
695 if( scen->has_map_extra() ) {
696 // Map extras can add monster spawn points and similar and should be done before the main
697 // map is loaded.
698 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
699 }
700
701 // TODO: fix point types
702 tripoint lev = project_to<coords::sm>( omtstart ).raw();
703 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
704 lev.x -= HALF_MAPSIZE;
705 lev.y -= HALF_MAPSIZE;
706 load_map( lev );
707
710 // Do this after the map cache has been built!
711 start_loc.place_player( u );
712 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
715 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
717 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
718
719 u.moves = 0;
720 u.process_turn(); // process_turn adds the initial move points
724 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
726
727 //Reset character safe mode/pickup rules
732
733 //Put some NPCs in there!
734 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
735 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
736 !g->scen->has_flag( "LONE_START" ) ) ) {
738 }
739 //Load NPCs. Set nearby npcs to active.
740 load_npcs();
741 // Spawn the monsters
742 const bool spawn_near =
743 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
744 // Surrounded start ones
745 if( spawn_near ) {
746 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
747 }
748
749 m.spawn_monsters( !spawn_near ); // Static monsters
750
751 // Make sure that no monsters are near the player
752 // This can happen in lab starts
753 if( !spawn_near ) {
754 for( monster &critter : all_monsters() ) {
755 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
756 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
757 remove_zombie( critter );
758 }
759 }
760 }
761
762 //Create mutation_category_level
764 //Calculate mutation drench protection stats
767 if( scen->has_flag( "FIRE_START" ) ) {
768 start_loc.burn( omtstart, 3, 3 );
769 }
770 if( scen->has_flag( "INFECTED" ) ) {
772 }
773 if( scen->has_flag( "BAD_DAY" ) ) {
774 u.add_effect( effect_flu, 1000_minutes );
775 u.add_effect( effect_drunk, 270_minutes );
776 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
777 }
778 if( scen->has_flag( "HELI_CRASH" ) ) {
779 start_loc.handle_heli_crash( u );
780 bool success = false;
781 for( auto v : m.get_vehicles() ) {
782 std::string name = v.v->type.str();
783 std::string search = std::string( "helicopter" );
784 if( name.find( search ) != std::string::npos ) {
785 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
786 const tripoint pos = vp.pos();
787 u.setpos( pos );
788
789 // Delete the items that would have spawned here from a "corpse"
790 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
791 vehicle_stack here = v.v->get_items( sp );
792
793 for( auto iter = here.begin(); iter != here.end(); ) {
794 iter = here.erase( iter );
795 }
796 }
797
798 auto mons = critter_tracker->find( pos );
799 if( mons != nullptr ) {
800 critter_tracker->remove( *mons );
801 }
802
803 success = true;
804 break;
805 }
806 if( success ) {
807 v.v->name = "Bird Wreckage";
808 break;
809 }
810 }
811 }
812 }
813 if( scen->has_flag( "BORDERED" ) ) {
814 overmap &starting_om = get_cur_om();
815 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
816 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
818 }
819
820 }
821 for( auto &e : u.inv_dump() ) {
822 e->set_owner( g->u );
823 }
824 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
825 update_map( u );
826 // Profession pets
827 for( const mtype_id &elem : u.starting_pets ) {
828 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
829 mon->friendly = -1;
830 mon->add_effect( effect_pet, 1_turns, num_bp );
831 } else {
832 add_msg( m_debug, "cannot place starting pet, no space!" );
833 }
834 }
835 // Assign all of this scenario's missions to the player.
836 for( const mission_type_id &m : scen->missions() ) {
837 const auto mission = mission::reserve_new( m, character_id() );
838 mission->assign( u );
839 }
840
841 g->events().send<event_type::game_start>( u.getID() );
842 return true;
843}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2278
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7956
void set_stamina(int new_stamina)
Definition: character.cpp:7218
time_point next_climate_control_check
Definition: character.h:2277
int get_stamina_max() const
Definition: character.cpp:7209
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7933
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:12119
void create_starting_npcs()
Definition: game.cpp:971
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:12417
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:845
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6360
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2153
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:687
vproto_id starting_vehicle
Definition: player.h:699
std::vector< mtype_id > starting_pets
Definition: player.h:700
start_location_id start_location
Definition: player.h:688
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
string_id< overmap_special > overmap_special_id
Definition: omdata.h:37
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:98
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10918 of file game.cpp.

10919{
10920 // Find target items and quantities thereof for the new activity
10921 std::vector<item_location> target_items;
10922 std::vector<int> quantities;
10923
10924 map_stack items = m.i_at( pos );
10925 for( item &it : items ) {
10926 // Liquid cannot be picked up
10927 if( it.made_of( LIQUID ) ) {
10928 continue;
10929 }
10930 target_items.emplace_back( map_cursor( pos ), &it );
10931 // Quantity of 0 means move all
10932 quantities.push_back( 0 );
10933 }
10934
10935 if( target_items.empty() ) {
10936 // Nothing to haul
10937 return;
10938 }
10939
10940 // Whether the destination is inside a vehicle (not supported)
10941 const bool to_vehicle = false;
10942 // Destination relative to the player
10943 const tripoint relative_destination{};
10944
10946 target_items,
10947 quantities,
10948 to_vehicle,
10949 relative_destination
10950 ) ) );
10951}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 3094 of file game.cpp.

3095{
3096 return *stats_tracker_ptr;
3097}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 5081 of file game.cpp.

5082{
5083 if( &a == &b ) {
5084 // No need to do anything, but print a debugmsg anyway
5085 debugmsg( "Tried to swap %s with itself", a.disp_name() );
5086 return true;
5087 }
5088 if( critter_at( a.pos() ) != &a ) {
5089 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5090 b.disp_name(), critter_at( a.pos() )->disp_name() );
5091 return false;
5092 }
5093 if( critter_at( b.pos() ) != &b ) {
5094 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5095 a.disp_name(), critter_at( b.pos() )->disp_name() );
5096 return false;
5097 }
5098 // Simplify by "sorting" the arguments
5099 // Only the first argument can be u
5100 // If swapping player/npc with a monster, monster is second
5101 bool a_first = a.is_player() ||
5102 ( a.is_npc() && !b.is_player() );
5103 Creature &first = a_first ? a : b;
5104 Creature &second = a_first ? b : a;
5105 // Possible options:
5106 // both first and second are monsters
5107 // second is a monster, first is a player or an npc
5108 // first is a player, second is an npc
5109 // both first and second are npcs
5110 if( first.is_monster() ) {
5111 monster *m1 = dynamic_cast< monster * >( &first );
5112 monster *m2 = dynamic_cast< monster * >( &second );
5113 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
5114 debugmsg( "Couldn't swap two monsters" );
5115 return false;
5116 }
5117
5118 critter_tracker->swap_positions( *m1, *m2 );
5119 return true;
5120 }
5121
5122 player *u_or_npc = dynamic_cast< player * >( &first );
5123 player *other_npc = dynamic_cast< player * >( &second );
5124
5125 if( u_or_npc->in_vehicle ) {
5126 m.unboard_vehicle( u_or_npc->pos() );
5127 }
5128
5129 if( other_npc && other_npc->in_vehicle ) {
5130 m.unboard_vehicle( other_npc->pos() );
5131 }
5132
5133 tripoint temp = second.pos();
5134 second.setpos( first.pos() );
5135
5136 if( first.is_player() ) {
5137 walk_move( temp );
5138 } else {
5139 first.setpos( temp );
5140 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5141 m.board_vehicle( u_or_npc->pos(), u_or_npc );
5142 }
5143 }
5144
5145 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5146 m.board_vehicle( other_npc->pos(), other_npc );
5147 }
5148 return true;
5149}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:9320
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7418 of file game.cpp.

7419{
7420 popup( _( "This binary was not compiled with tiles support." ) );
7421 return false;
7422}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7412 of file game.cpp.

7413{
7414 popup( _( "This binary was not compiled with tiles support." ) );
7415 return false;
7416}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 536 of file game.cpp.

537{
538 if( fullscreen ) {
539 was_fullscreen = true;
541 } else {
542 was_fullscreen = false;
543 }
544}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11726 of file game.cpp.

11727{
11729}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 498 of file game.cpp.

499{
500#if !defined(TILES)
503#else
504 toggle_fullscreen_window();
505#endif
506}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 508 of file game.cpp.

509{
510#if defined(TILES)
512 clear_window_area( w_pixel_minimap );
513 }
516#endif // TILES
517}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2616 of file game.cpp.

2617{
2618 bool new_destination = true;
2619 if( !destination_preview.empty() ) {
2620 auto &final_destination = destination_preview.back();
2621 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2622 // Second click
2623 new_destination = false;
2625 destination_preview.clear();
2627 if( act == ACTION_NULL ) {
2628 // Something went wrong
2630 return false;
2631 }
2632 }
2633 }
2634
2635 if( new_destination ) {
2637 u.get_path_avoid() );
2638 return false;
2639 }
2640
2641 return true;
2642}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2644 of file game.cpp.

2645{
2646 const bool cleared_destination = !destination_preview.empty();
2648 destination_preview.clear();
2649
2650 if( cleared_destination ) {
2651 // Produce no-op if auto-move had just been cleared on this action
2652 // e.g. from a previous single left mouse click. This has the effect
2653 // of right-click canceling an auto-move before it is initiated.
2654 return false;
2655 }
2656
2657 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2658 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2659 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2660 if( !u.sees( *mon ) ) {
2661 add_msg( _( "Nothing relevant here." ) );
2662 return false;
2663 }
2664
2665 if( !u.weapon.is_gun() ) {
2666 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2667 return false;
2668 }
2669
2670 // TODO: Add weapon range check. This requires weapon to be reloaded.
2671
2672 act = ACTION_FIRE;
2673 } else if( is_adjacent &&
2674 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2675 true ) ) {
2676 act = ACTION_CLOSE;
2677 } else if( is_self ) {
2679 } else if( is_adjacent ) {
2681 } else {
2682 add_msg( _( "Nothing relevant here." ) );
2683 return false;
2684 }
2685
2686 return true;
2687}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3953
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload()

bool game::unload ( item_location  loc)

Definition at line 9016 of file game.cpp.

9017{
9018 return u.unload( loc );
9019}
bool unload(item_location loc)
Definition: player.cpp:3047

References u, and player::unload().

Referenced by inventory_item_menu().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 949 of file game.cpp.

950{
951 for( const auto &npc : active_npc ) {
952 npc->on_unload();
953 }
954
955 active_npc.clear();
956}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2642

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map( tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ) );
207
208 safe_mode = static_cast<safe_mode_type>( tmprun );
209 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
211 }
212
213 std::string linebuff;
214 std::string linebuf;
215 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
216 scent.deserialize( linebuf );
217 scent.deserialize( linebuff, true );
218 } else {
219 scent.reset();
220 }
221 data.read( "active_monsters", *critter_tracker );
222
223 coming_to_stairs.clear();
224 for( auto elem : data.get_array( "stair_monsters" ) ) {
225 monster stairtmp;
226 elem.read( stairtmp );
227 coming_to_stairs.push_back( stairtmp );
228 }
229
230 if( data.has_object( "kill_tracker" ) ) {
231 data.read( "kill_tracker", *kill_tracker_ptr );
232 } else {
233 // Legacy support for when kills were stored directly in game
234 std::map<mtype_id, int> kills;
235 std::vector<std::string> npc_kills;
236 for( const JsonMember member : data.get_object( "kills" ) ) {
237 kills[mtype_id( member.name() )] = member.get_int();
238 }
239
240 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
241 npc_kills.push_back( npc_name );
242 }
243
244 kill_tracker_ptr->reset( kills, npc_kills );
245 }
246
247 data.read( "player", u );
248 data.read( "stats_tracker", *stats_tracker_ptr );
249 data.read( "achievements_tracker", *achievements_tracker_ptr );
250 data.read( "token_provider", token_provider_ptr );
251 Messages::deserialize( data );
252
253 } catch( const JsonError &jsonerr ) {
254 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
255 return;
256 }
257}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:259
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:402
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1207 of file savegame.cpp.

1208{
1210 chkversion( fin );
1211 if( savegame_loading_version < 11 ) {
1212 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1213 popup->message(
1214 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1218 }
1219 try {
1220 // single-pass parsing example
1221 JsonIn jsin( fin );
1222 jsin.start_object();
1223 while( !jsin.end_object() ) {
1224 std::string name = jsin.get_member_name();
1225 if( name == "next_mission_id" ) {
1226 next_mission_id = jsin.get_int();
1227 } else if( name == "next_npc_id" ) {
1228 next_npc_id.deserialize( jsin );
1229 } else if( name == "active_missions" ) {
1231 } else if( name == "factions" ) {
1232 jsin.read( *faction_manager_ptr );
1233 } else if( name == "seed" ) {
1234 jsin.read( seed );
1235 } else if( name == "weather" ) {
1236 JsonObject w = jsin.get_object();
1237 w.read( "lightning", get_weather().lightning_active );
1238 } else {
1239 // silently ignore anything else
1240 jsin.skip_value();
1241 }
1242 }
1243 } catch( const JsonError &e ) {
1244 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1245 }
1246}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1197

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 11186 of file game.cpp.

11187{
11188 point shift;
11189
11190 while( x < HALF_MAPSIZE_X ) {
11191 x += SEEX;
11192 shift.x--;
11193 }
11194 while( x >= HALF_MAPSIZE_X + SEEX ) {
11195 x -= SEEX;
11196 shift.x++;
11197 }
11198 while( y < HALF_MAPSIZE_Y ) {
11199 y += SEEY;
11200 shift.y--;
11201 }
11202 while( y >= HALF_MAPSIZE_Y + SEEY ) {
11203 y -= SEEY;
11204 shift.y++;
11205 }
11206
11207 if( shift == point_zero ) {
11208 // adjust player position
11209 u.setpos( tripoint( x, y, get_levz() ) );
11210 // Update what parts of the world map we can see
11211 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
11212 // TODO: only make this call if we changed z-level
11214 // Not actually shifting the submaps, all the stuff below would do nothing
11215 return point_zero;
11216 }
11217
11218 // this handles loading/unloading submaps that have scrolled on or off the viewport
11219 // NOLINTNEXTLINE(cata-use-named-point-constants)
11220 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
11221 point remaining_shift = shift;
11222 while( remaining_shift != point_zero ) {
11223 point this_shift = clamp( remaining_shift, size_1 );
11224 m.shift( this_shift );
11225 remaining_shift -= this_shift;
11226 }
11227
11228 grid_tracker_ptr->load( m );
11229
11230 // Shift monsters
11231 shift_monsters( tripoint( shift, 0 ) );
11232 const point shift_ms = sm_to_ms_copy( shift );
11233 u.shift_destination( -shift_ms );
11234
11235 // Shift NPCs
11236 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
11237 ( *it )->shift( shift );
11238 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
11239 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
11240 //Remove the npc from the active list. It remains in the overmap list.
11241 ( *it )->on_unload();
11242 it = active_npc.erase( it );
11243 } else {
11244 it++;
11245 }
11246 }
11247
11248 scent.shift( shift_ms );
11249
11250 // Also ensure the player is on current z-level
11251 // get_levz() should later be removed, when there is no longer such a thing
11252 // as "current z-level"
11253 u.setpos( tripoint( x, y, get_levz() ) );
11254
11255 // Only do the loading after all coordinates have been shifted.
11256
11257 // Check for overmap saved npcs that should now come into view.
11258 // Put those in the active list.
11259 load_npcs();
11260
11261 // Make sure map cache is consistent since it may have shifted.
11262 if( m.has_zlevels() ) {
11263 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
11264 m.invalidate_map_cache( zlev );
11265 }
11266 } else {
11268 }
11270
11271 // Spawn monsters if appropriate
11272 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
11273 m.spawn_monsters( false ); // Static monsters
11274
11275 // Update what parts of the world map we can see
11277
11278 return shift;
11279}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11555
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6648
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 11180 of file game.cpp.

11181{
11182 point p2( p.posx(), p.posy() );
11183 return update_map( p2.x, p2.y );
11184}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 11281 of file game.cpp.

11282{
11283 const tripoint_abs_omt ompos = u.global_omt_location();
11284 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
11285 const int dist_squared = dist * dist;
11286 // We can always see where we're standing
11287 overmap_buffer.set_seen( ompos, true );
11288 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
11289 const point_rel_omt delta = p.xy() - ompos.xy();
11290 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
11291 if( trigdist && h_squared > dist_squared ) {
11292 continue;
11293 }
11294 if( delta == point_rel_omt() ) {
11295 // 1. This case is already handled outside of the loop
11296 // 2. Calculating multiplier would cause division by zero
11297 continue;
11298 }
11299 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
11300 point abs_delta = delta.raw().abs();
11301 int max_delta = std::max( abs_delta.x, abs_delta.y );
11302 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
11303 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
11304 float sight_points = dist;
11305 for( auto it = line.begin();
11306 it != line.end() && sight_points >= 0; ++it ) {
11307 const oter_id &ter = overmap_buffer.ter( *it );
11308 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
11309 }
11310 if( sight_points >= 0 ) {
11311 tripoint_abs_omt seen( p );
11312 do {
11313 overmap_buffer.set_seen( seen, true );
11314 --seen.z();
11315 } while( seen.z() >= 0 );
11316 }
11317 }
11318}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:766
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:234

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 11333 of file game.cpp.

11334{
11335 // Search for the stairs closest to the player.
11336 std::vector<int> stairx;
11337 std::vector<int> stairy;
11338 std::vector<int> stairdist;
11339
11340 const bool from_below = monstairz < get_levz();
11341
11342 if( coming_to_stairs.empty() ) {
11343 return;
11344 }
11345
11346 if( m.has_zlevels() ) {
11347 debugmsg( "%d monsters coming to stairs on a map with z-levels",
11348 coming_to_stairs.size() );
11349 coming_to_stairs.clear();
11350 }
11351
11352 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
11353 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
11354 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
11355 stairx.push_back( dest.x );
11356 stairy.push_back( dest.y );
11357 stairdist.push_back( rl_dist( dest, u.pos() ) );
11358 }
11359 }
11360 if( stairdist.empty() ) {
11361 return; // Found no stairs?
11362 }
11363
11364 // Find closest stairs.
11365 size_t si = 0;
11366 for( size_t i = 0; i < stairdist.size(); i++ ) {
11367 if( stairdist[i] < stairdist[si] ) {
11368 si = i;
11369 }
11370 }
11371
11372 // Find up to 4 stairs for distance stairdist[si] +1
11373 std::vector<int> nearest;
11374 nearest.push_back( si );
11375 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
11376 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
11377 nearest.push_back( i );
11378 }
11379 }
11380 // Randomize the stair choice
11381 si = random_entry_ref( nearest );
11382
11383 // Attempt to spawn zombies.
11384 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
11385 point mpos( stairx[si], stairy[si] );
11386 monster &critter = coming_to_stairs[i];
11387 const tripoint dest {
11388 mpos, g->get_levz()
11389 };
11390
11391 // We might be not be visible.
11392 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
11393 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
11394 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
11395 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
11396 continue;
11397 }
11398
11399 critter.staircount -= 4;
11400 // Let the player know zombies are trying to come.
11401 if( u.sees( dest ) ) {
11402 std::string dump;
11403 if( critter.staircount > 4 ) {
11404 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
11405 } else {
11406 if( critter.staircount > 0 ) {
11407 dump += ( from_below ?
11408 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
11409 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
11410 critter.name(),
11411 m.tername( dest ) ) :
11412 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
11413 critter.name(),
11414 m.tername( dest ) ) );
11415 }
11416 }
11417
11418 add_msg( m_warning, dump );
11419 } else {
11421 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
11422 }
11423
11424 if( critter.staircount > 0 ) {
11425 continue;
11426 }
11427
11428 if( is_empty( dest ) ) {
11429 critter.spawn( dest );
11430 critter.staircount = 0;
11431 place_critter_at( make_shared_fast<monster>( critter ), dest );
11432 if( u.sees( dest ) ) {
11433 if( !from_below ) {
11434 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
11435 critter.name(),
11436 m.tername( dest ) );
11437 } else {
11438 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
11439 critter.name(),
11440 m.tername( dest ) );
11441 }
11442 }
11443 coming_to_stairs.erase( coming_to_stairs.begin() + i );
11444 continue;
11445 } else if( u.pos() == dest ) {
11446 // Monster attempts to push player of stairs
11448 int tries = 0;
11449
11450 // the critter is now right on top of you and will attack unless
11451 // it can find a square to push you into with one of his tries.
11452 const int creature_push_attempts = 9;
11453 const int player_throw_resist_chance = 3;
11454
11455 critter.spawn( dest );
11456 while( tries < creature_push_attempts ) {
11457 tries++;
11458 push.x = rng( -1, 1 );
11459 push.y = rng( -1, 1 );
11460 point ipos( mpos + push );
11461 tripoint pos( ipos, get_levz() );
11462 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
11463 critter.can_move_to( pos ) ) {
11464 bool resiststhrow = ( u.is_throw_immune() ) ||
11466 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
11467 u.moves -= 25; // small charge for avoiding the push altogether
11468 add_msg( _( "The %s fails to push you back!" ),
11469 critter.name() );
11470 return; //judo or leg brace prevent you from getting pushed at all
11471 }
11472 // Not accounting for tentacles latching on, so..
11473 // Something is about to happen, lets charge half a move
11474 u.moves -= 50;
11475 if( resiststhrow && ( u.is_throw_immune() ) ) {
11476 //we have a judoka who isn't getting pushed but counterattacking now.
11477 mattack::thrown_by_judo( &critter );
11478 return;
11479 }
11480 std::string msg;
11481 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
11482 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
11483 // dodge 12 - never get downed
11484 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
11485 u.add_effect( effect_downed, 2_turns );
11486 msg = _( "The %s pushed you back hard!" );
11487 } else {
11488 msg = _( "The %s pushed you back!" );
11489 }
11490 add_msg( m_warning, msg.c_str(), critter.name() );
11491 u.setx( u.posx() + push.x );
11492 u.sety( u.posy() + push.y );
11493 return;
11494 }
11495 }
11497 _( "The %s tried to push you back but failed! It attacks you!" ),
11498 critter.name() );
11499 critter.melee_attack( u );
11500 u.moves -= 50;
11501 return;
11502 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11503 // Monster attempts to displace a monster from the stairs
11504 monster &other = *mon_ptr;
11505 critter.spawn( dest );
11506
11507 // the critter is now right on top of another and will push it
11508 // if it can find a square to push it into inside of his tries.
11509 const int creature_push_attempts = 9;
11510 const int creature_throw_resist = 4;
11511
11512 int tries = 0;
11513 point push2;
11514 while( tries < creature_push_attempts ) {
11515 tries++;
11516 push2.x = rng( -1, 1 );
11517 push2.y = rng( -1, 1 );
11518 point ipos2( mpos + push2 );
11519 tripoint pos( ipos2, get_levz() );
11520 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11521 continue;
11522 }
11523 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11524 other.setpos( tripoint( ipos2, get_levz() ) );
11525 other.moves -= 50;
11526 std::string msg;
11527 if( one_in( creature_throw_resist ) ) {
11528 other.add_effect( effect_downed, 2_turns );
11529 msg = _( "The %1$s pushed the %2$s hard." );
11530 } else {
11531 msg = _( "The %1$s pushed the %2$s." );
11532 }
11533 add_msg( m_neutral, msg, critter.name(), other.name() );
11534 return;
11535 }
11536 }
11537 return;
11538 }
11539 }
11540}
void setx(int x)
Definition: character.h:847
void sety(int y)
Definition: character.h:850
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:782
int monstairz
Definition: game.h:1032
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8443
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:249
int posy() const override
Definition: monster.h:498
void melee_attack(Creature &target)
Definition: monster.cpp:1370
int staircount
Definition: monster.h:509
void spawn(const tripoint &p)
Definition: monster.cpp:481
int posx() const override
Definition: monster.h:495
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4581
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 5031 of file game.cpp.

5032{
5033 return critter_tracker->update_pos( critter, pos );
5034}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4814 of file game.cpp.

4815{
4816 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4817 add_msg( m_info, _( "You can not read a computer screen!" ) );
4818 return;
4819 }
4820 if( u.is_blind() ) {
4821 // we don't have screen readers in game
4822 add_msg( m_info, _( "You can not see a computer screen!" ) );
4823 return;
4824 }
4825 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4826 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4827 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4828 return;
4829 }
4830
4831 computer *used = m.computer_at( p );
4832
4833 if( used == nullptr ) {
4834 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4835 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4836 } else {
4837 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4838 }
4839 return;
4840 }
4841
4842 computer_session( *used ).use();
4843}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5520
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2036 of file game.cpp.

2037{
2038 basecamp camp = m.hoist_submap_camp( u.pos() );
2039 if( camp.is_valid() ) {
2040 overmap_buffer.add_camp( camp );
2042 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2043 std::string camp_name = _( "Faction Camp" );
2044 camp.set_name( camp_name );
2045 overmap_buffer.add_camp( camp );
2047 }
2048}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5551
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5546
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1978 of file game.cpp.

1979{
1980 for( auto &veh : m.get_vehicles() ) {
1981 vehicle *v = veh.v;
1984 if( other_v ) {
1985 // the other vehicle is towing us.
1986 v->tow_data.set_towing( other_v, v );
1988 }
1989 }
1990 }
1991}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:5940
towing_data tow_data
Definition: vehicle.h:1924

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 1993 of file game.cpp.

1994{
1995 for( monster &m : all_monsters() ) {
1996 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
1997 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
1998 if( !mounted_pl ) {
1999 // Target no longer valid.
2000 m.mounted_player_id = character_id();
2001 m.remove_effect( effect_ridden );
2002 continue;
2003 }
2004 mounted_pl->mounted_creature = shared_from( m );
2005 mounted_pl->setpos( m.pos() );
2006 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2007 m.mounted_player = mounted_pl;
2008 }
2009 }
2010}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2012 of file game.cpp.

2013{
2014 // Make sure visible followers are in the list.
2015 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2016 return guy.is_player_ally();
2017 } );
2018 for( npc *guy : visible_followers ) {
2019 update_faction_api( guy );
2020 add_npc_follower( guy->getID() );
2021 }
2022 // Make sure overmapbuffered NPC followers are in the list.
2023 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2024 npc *guy = temp_guy.get();
2025 if( guy->is_player_ally() ) {
2026 update_faction_api( guy );
2027 add_npc_follower( guy->getID() );
2028 }
2029 }
2030 // Make sure that serialized player followers sync up with game list
2031 for( const auto &temp_id : u.follower_ids ) {
2032 add_npc_follower( temp_id );
2033 }
2034}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1958
static void update_faction_api(npc *guy)
Definition: game.cpp:1970

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10507 of file game.cpp.

10508{
10509 if( u.is_mounted() ) {
10510 auto mons = u.mounted_creature.get();
10511 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10512 if( !mons->check_mech_powered() ) {
10513 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10514 mons->get_name() );
10515 return;
10516 }
10517 }
10518 }
10519
10520 // > and < are used for diving underwater.
10521 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10522 if( movez == -1 ) {
10523 if( u.is_underwater() ) {
10524 add_msg( m_info, _( "You are already underwater!" ) );
10525 return;
10526 }
10527 if( u.worn_with_flag( "FLOTATION" ) ) {
10528 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10529 return;
10530 }
10531 u.set_underwater( true );
10532 ///\EFFECT_STR increases breath-holding capacity while diving
10533 u.oxygen = 30 + 2 * u.str_cur;
10534 add_msg( _( "You dive underwater!" ) );
10535 } else {
10536 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10537 u.set_underwater( false );
10538 add_msg( _( "You surface." ) );
10539 } else {
10540 add_msg( m_info, _( "You try to surface but can't!" ) );
10541 }
10542 }
10543 u.moves -= 100;
10544 return;
10545 }
10546
10547 // Force means we're going down, even if there's no staircase, etc.
10548 bool climbing = false;
10549 int move_cost = 100;
10550 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10551 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10552 // Climbing
10553 if( m.has_floor_or_support( stairs ) ) {
10554 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10555 return;
10556 }
10557
10558 std::vector<tripoint> pts;
10559 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10560 if( m.passable( pt ) &&
10561 m.has_floor_or_support( pt ) ) {
10562 pts.push_back( pt );
10563 }
10564 }
10565
10566 const int cost = u.climbing_cost( u.pos(), stairs );
10567
10568 if( cost == 0 ) {
10569 if( u.has_trait( trait_WEB_ROPE ) ) {
10570 if( pts.empty() ) {
10571 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10572 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10573 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10574 add_msg( m_info, _( "You can't spin a web rope there." ) );
10575 } else if( g->m.has_furn( u.pos() ) ) {
10576 add_msg( m_info, _( "There is already furniture at that location." ) );
10577 } else {
10578 if( query_yn( "Spin a rope and climb?" ) ) {
10579 add_msg( m_good, _( "You spin a rope of web." ) );
10580 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10581 u.mod_moves( to_turns<int>( 2_seconds ) );
10583 vertical_move( movez, force, peeking );
10584 }
10585 }
10586 }
10587
10588 } else {
10589 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10590
10591 }
10592 return;
10593
10594 }
10595
10596 if( cost <= 0 || pts.empty() ) {
10597 add_msg( m_info,
10598 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10599 return;
10600 } else {
10601 // TODO: Make it an extended action
10602 climbing = true;
10603 move_cost = cost;
10604
10606 if( !pnt ) {
10607 return;
10608 }
10609 stairs = *pnt;
10610 }
10611 }
10612
10613 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10614 add_msg( m_info, _( "You can't go down here!" ) );
10615 return;
10616 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10617 add_msg( m_info, _( "You can't go up here!" ) );
10618 return;
10619 }
10620
10621 if( force ) {
10622 // Let go of a grabbed cart.
10623 u.grab( OBJECT_NONE );
10624 } else if( u.grab_point != tripoint_zero ) {
10625 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10626 return;
10627 }
10628
10629 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10630 // is called or when the map is loaded on new z-level (== false).
10631 // This caches the z-level we start the movement on (current) and the level we're want to end.
10632 const int z_before = get_levz();
10633 const int z_after = get_levz() + movez;
10634 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10635 debugmsg( "Tried to move outside allowed range of z-levels" );
10636 return;
10637 }
10638
10639 if( !u.move_effects( false ) ) {
10640 return;
10641 }
10642
10643 // Check if there are monsters are using the stairs.
10644 bool slippedpast = false;
10645 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10646 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10647 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10648 coming_to_stairs[0].name() );
10649 // Roll.
10650 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10651
10652 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10653 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10654 ///\EFFECT_STR increases chance of moving past monsters on stairs
10655
10656 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10657 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10658 if( coming_to_stairs.size() > 4 ) {
10659 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10660 dexroll /= 4;
10661 strroll /= 2;
10662 } else if( coming_to_stairs.size() > 1 ) {
10663 add_msg( m_warning, _( "There's something else behind it!" ) );
10664 dexroll /= 2;
10665 }
10666
10667 if( dexroll < 14 || strroll < 12 ) {
10669 u.moves -= 100;
10670 return;
10671 }
10672
10673 add_msg( _( "You manage to slip past!" ) );
10674 slippedpast = true;
10675 u.moves -= 100;
10676 }
10677
10678 // Shift the map up or down
10679
10680 std::unique_ptr<map> tmp_map_ptr;
10681 if( !m.has_zlevels() ) {
10682 tmp_map_ptr = std::make_unique<map>();
10683 }
10684
10685 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10686 if( m.has_zlevels() ) {
10687 // We no longer need to shift the map here! What joy
10688 } else {
10689 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10690 }
10691
10692 // Find the corresponding staircase
10693 bool rope_ladder = false;
10694 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10695 if( !force && !climbing ) {
10696 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10697 if( !pnt ) {
10698 return;
10699 }
10700 stairs = *pnt;
10701 }
10702
10703 if( !force ) {
10704 monstairz = z_before;
10705 }
10706 // Save all monsters that can reach the stairs, remove them from the tracker,
10707 // then despawn the remaining monsters. Because it's a vertical shift, all
10708 // monsters are out of the bounds of the map and will despawn.
10709 shared_ptr_fast<monster> stored_mount;
10710 if( u.is_mounted() && !m.has_zlevels() ) {
10711 // Store a *copy* of the mount, so we can remove the original monster instance
10712 // from the tracker before the map shifts.
10713 // Map shifting would otherwise just despawn the mount and would later respawn it.
10714 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10716 }
10717 if( !m.has_zlevels() ) {
10718 const tripoint to = u.pos();
10719 for( monster &critter : all_monsters() ) {
10720 // if its a ladder instead of stairs - most zombies can't climb that.
10721 // unless that have a special flag to allow them to do so.
10722 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10723 critter.has_effect( effect_ridden ) ||
10724 critter.has_effect( effect_tied ) ) {
10725 continue;
10726 }
10727 int turns = critter.turns_to_reach( to.xy() );
10728 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10729 && !slippedpast ) {
10730 critter.staircount = 10 + turns;
10731 critter.on_unload();
10732 coming_to_stairs.push_back( critter );
10733 remove_zombie( critter );
10734 }
10735 }
10736 auto mons = critter_tracker->find( g->u.pos() );
10737 if( mons != nullptr ) {
10738 critter_tracker->remove( *mons );
10739 }
10740 shift_monsters( tripoint( 0, 0, movez ) );
10741 }
10742
10743 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10744 std::vector<monster *> monsters_following;
10745 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10746 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10747 [this]( const shared_ptr_fast<npc> &np ) {
10748 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10749 rl_dist( np->pos(), u.pos() ) < 2;
10750 } );
10751 }
10752
10753 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10754 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10755 for( monster &critter : all_monsters() ) {
10756 if( ladder && !critter.climbs() ) {
10757 continue;
10758 }
10759 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10760 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10761 !critter.has_effect( effect_tied ) ) ) {
10762 monsters_following.push_back( &critter );
10763 }
10764 }
10765 }
10766
10767 if( u.is_mounted() ) {
10768 monster *crit = u.mounted_creature.get();
10769 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10770 crit->use_mech_power( -1 );
10771 if( u.movement_mode_is( CMM_WALK ) ) {
10772 crit->use_mech_power( -2 );
10773 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10774 crit->use_mech_power( -1 );
10775 } else if( u.movement_mode_is( CMM_RUN ) ) {
10776 crit->use_mech_power( -3 );
10777 }
10778 }
10779 } else {
10780 u.moves -= move_cost;
10781 }
10782 for( const auto &np : npcs_to_bring ) {
10783 if( np->in_vehicle ) {
10784 m.unboard_vehicle( np->pos() );
10785 }
10786 }
10787 const tripoint old_pos = g->u.pos();
10788 point submap_shift;
10789 vertical_shift( z_after );
10790 if( !force ) {
10791 submap_shift = update_map( stairs.x, stairs.y );
10792 }
10793
10794 // if an NPC or monster is on the stiars when player ascends/descends
10795 // they may end up merged on th esame tile, do some displacement to resolve that.
10796 // if, in the weird case of it not being possible to displace;
10797 // ( how did the player even manage to approach the stairs, if so? )
10798 // then nothing terrible happens, its just weird.
10799 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10800 std::string crit_name;
10801 bool player_displace = false;
10803 if( displace.has_value() ) {
10804 npc *guy = g->critter_at<npc>( u.pos(), true );
10805 if( guy ) {
10806 crit_name = guy->get_name();
10807 tripoint old_pos = guy->pos();
10808 if( !guy->is_enemy() ) {
10809 guy->move_away_from( u.pos(), true );
10810 if( old_pos != guy->pos() ) {
10811 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10812 }
10813 } else {
10814 player_displace = true;
10815 }
10816 }
10817 monster *mon = g->critter_at<monster>( u.pos(), true );
10818 // if the monster is ridden by the player or an NPC:
10819 // Dont displace them. If they are mounted by a friendly NPC,
10820 // then the NPC will already have been displaced just above.
10821 // if they are ridden by the player, we want them to coexist on same tile
10822 if( mon && !mon->mounted_player ) {
10823 crit_name = mon->get_name();
10824 if( mon->friendly == -1 ) {
10825 mon->setpos( *displace );
10826 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10827 } else {
10828 player_displace = true;
10829 }
10830 }
10831 if( player_displace ) {
10832 u.setpos( *displace );
10833 u.moves -= 20;
10834 add_msg( _( "You push past %s blocking the way." ), crit_name );
10835 }
10836 } else {
10837 debugmsg( "Failed to find a spot to displace into." );
10838 }
10839 }
10840
10841 // Now that we know the player's destination position, we can move their mount as well
10842 if( u.is_mounted() ) {
10843 if( stored_mount ) {
10844 assert( !m.has_zlevels() );
10845 stored_mount->spawn( g->u.pos() );
10846 if( critter_tracker->add( stored_mount ) ) {
10847 u.mounted_creature = stored_mount;
10848 }
10849 } else {
10850 u.mounted_creature->setpos( g->u.pos() );
10851 }
10852 }
10853
10854 if( !npcs_to_bring.empty() ) {
10855 // Would look nicer randomly scrambled
10856 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10857 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10858 [this]( const tripoint & c ) {
10859 return !is_empty( c );
10860 } ), candidates.end() );
10861
10862 for( const auto &np : npcs_to_bring ) {
10863 const auto found = std::find_if( candidates.begin(), candidates.end(),
10864 [this, np]( const tripoint & c ) {
10865 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10866 } );
10867 if( found != candidates.end() ) {
10868 // TODO: De-uglify
10869 np->setpos( *found );
10870 np->place_on_map();
10871 np->setpos( *found );
10872 candidates.erase( found );
10873 }
10874
10875 if( candidates.empty() ) {
10876 break;
10877 }
10878 }
10879
10880 reload_npcs();
10881 }
10882
10883 // This ugly check is here because of stair teleport bullshit
10884 // TODO: Remove stair teleport bullshit
10885 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10886 for( monster *m : monsters_following ) {
10887 m->set_dest( g->u.pos() );
10888 }
10889 }
10890
10891 if( rope_ladder ) {
10892 m.ter_set( u.pos(), t_rope_up );
10893 }
10894
10895 if( m.ter( stairs ) == t_manhole_cover ) {
10896 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10897 m.ter_set( stairs, t_manhole );
10898 }
10899
10900 // Wouldn't work and may do strange things
10901 if( u.is_hauling() && !m.has_zlevels() ) {
10902 add_msg( _( "You cannot haul items here." ) );
10903 u.stop_hauling();
10904 }
10905
10906 if( u.is_hauling() ) {
10907 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10908 start_hauling( adjusted_pos );
10909 }
10910
10911 m.invalidate_map_cache( g->get_levz() );
10912 // Upon force movement, traps can not be avoided.
10913 m.creature_on_trap( u, !force );
10914
10916}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:97
@ CMM_CROUCH
Definition: character.h:99
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1533
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:877
int oxygen
Definition: character.h:1596
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8957
std::string get_name() const override
Definition: character.cpp:6106
void start_hauling(const tripoint &pos)
Definition: game.cpp:10918
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10953
bool use_mech_power(int amt)
Definition: monster.cpp:2368
Character * mounted_player
Definition: monster.h:458
int climbing_cost(const tripoint &from, const tripoint &to) const
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
Definition: player.cpp:4330
void set_underwater(bool)
Definition: player.cpp:588
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:10457
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12576
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9344
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4159

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), player::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 11140 of file game.cpp.

11141{
11142 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
11143 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
11144 return;
11145 }
11146
11147 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
11148 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
11149 z_before, z_after );
11150 return;
11151 }
11152 // Figure out where we know there are up/down connectors
11153 // Fill in all the tiles we know about (e.g. subway stations)
11154 static const int REVEAL_RADIUS = 40;
11155 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
11156 const tripoint_abs_omt cursp_before( p.xy(), z_before );
11157 const tripoint_abs_omt cursp_after( p.xy(), z_after );
11158
11159 if( !overmap_buffer.seen( cursp_before ) ) {
11160 continue;
11161 }
11162 if( overmap_buffer.has_note( cursp_after ) ) {
11163 // Already has a note -> never add an AUTO-note
11164 continue;
11165 }
11166 const oter_id &ter = overmap_buffer.ter( cursp_before );
11167 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
11168 if( z_after > z_before && ter->has_flag( known_up ) &&
11169 !ter2->has_flag( known_down ) ) {
11170 overmap_buffer.set_seen( cursp_after, true );
11171 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
11172 } else if( z_after < z_before && ter->has_flag( known_down ) &&
11173 !ter2->has_flag( known_up ) ) {
11174 overmap_buffer.set_seen( cursp_after, true );
11175 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
11176 }
11177 }
11178}
bool inbounds_z(const int z) const
Definition: map.h:1643
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:91
@ known_down
Definition: omdata.h:90
bool has_flag(oter_flags flag) const
Definition: omdata.h:262

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 11103 of file game.cpp.

11104{
11105 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
11106 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
11107 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
11108 return;
11109 }
11110
11111 // TODO: Implement dragging stuff up/down
11112 u.grab( OBJECT_NONE );
11113
11114 scent.reset();
11115
11116 u.setz( z_after );
11117 const int z_before = get_levz();
11118 if( !m.has_zlevels() ) {
11120 m.access_cache( z_before ).vehicle_list.clear();
11121 m.access_cache( z_before ).zone_vehicles.clear();
11122 m.access_cache( z_before ).map_memory_seen_cache.reset();
11123 m.set_transparency_cache_dirty( z_before );
11124 m.set_outside_cache_dirty( z_before );
11125 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
11126 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
11127 reload_npcs();
11128 } else {
11129 // Shift the map itself
11130 m.vertical_shift( z_after );
11131 }
11132
11133 m.spawn_monsters( true );
11134 // this may be required after a vertical shift if z-levels are not enabled
11135 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
11137 vertical_notes( z_before, z_after );
11138}
void setz(int z)
Definition: character.h:853
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:11140
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:393
void set_outside_cache_dirty(const int zlev)
Definition: map.h:430
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6767
std::set< vehicle * > zone_vehicles
Definition: map.h:346
std::set< vehicle * > vehicle_list
Definition: map.h:345

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 9320 of file game.cpp.

9321{
9322 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
9323 if( u.get_size() > MS_MEDIUM ) {
9324 add_msg( m_warning, _( "You can't fit there." ) );
9325 return false; // character too large to fit through a tight passage
9326 }
9327 if( u.is_mounted() ) {
9328 monster *mount = u.mounted_creature.get();
9329 if( mount->get_size() > MS_MEDIUM ) {
9330 add_msg( m_warning, _( "Your mount can't fit there." ) );
9331 return false; // char's mount is too large for tight passages
9332 }
9333 }
9334 }
9335
9336 if( u.is_mounted() ) {
9337 auto mons = u.mounted_creature.get();
9338 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
9339 if( !mons->check_mech_powered() ) {
9340 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
9341 mons->get_name() );
9342 return false;
9343 }
9344 }
9345 if( !mons->move_effects( false ) ) {
9346 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
9347 return false;
9348 }
9349 }
9350 const optional_vpart_position vp_here = m.veh_at( u.pos() );
9351 const optional_vpart_position vp_there = m.veh_at( dest_loc );
9352
9353 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
9354 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
9355 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
9356
9357 const tripoint furn_pos = u.pos() + u.grab_point;
9358 const tripoint furn_dest = dest_loc + u.grab_point;
9359
9360 bool grabbed = u.get_grab_type() != OBJECT_NONE;
9361 if( grabbed ) {
9362 const tripoint dp = dest_loc - u.pos();
9363 pushing = dp == u.grab_point;
9364 pulling = dp == -u.grab_point;
9365 }
9366 if( grabbed && dest_loc.z != u.posz() ) {
9367 add_msg( m_warning, _( "You let go of the grabbed object." ) );
9368 grabbed = false;
9369 u.grab( OBJECT_NONE );
9370 }
9371
9372 // Now make sure we're actually holding something
9373 const vehicle *grabbed_vehicle = nullptr;
9374 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
9375 // We only care about shifting, because it's the only one that can change our destination
9376 if( m.has_furn( u.pos() + u.grab_point ) ) {
9377 shifting_furniture = !pushing && !pulling;
9378 } else {
9379 // We were grabbing a furniture that isn't there
9380 grabbed = false;
9381 }
9382 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
9383 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
9384 if( grabbed_vehicle == nullptr ) {
9385 // We were grabbing a vehicle that isn't there anymore
9386 grabbed = false;
9387 }
9388 } else if( grabbed ) {
9389 // We were grabbing something WEIRD, let's pretend we weren't
9390 grabbed = false;
9391 }
9392 if( u.grab_point != tripoint_zero && !grabbed ) {
9393 add_msg( m_warning, _( "Can't find grabbed object." ) );
9394 u.grab( OBJECT_NONE );
9395 }
9396
9397 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
9398 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
9399 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9400 tripoint diff = dest_loc - u.pos();
9401 if( diff.x < 0 ) {
9402 diff.x -= 2;
9403 } else if( diff.x > 0 ) {
9404 diff.x += 2;
9405 }
9406 if( diff.y < 0 ) {
9407 diff.y -= 2;
9408 } else if( diff.y > 0 ) {
9409 diff.y += 2;
9410 }
9411 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
9412 dest_loc );
9413 }
9414 return false;
9415 }
9416 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9417 return false;
9418 }
9419 if( u.is_mounted() && !pushing && vp_there ) {
9420 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
9421 return false;
9422 }
9423 u.set_underwater( false );
9424
9425 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
9426 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9427 if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "ALWAYS" &&
9428 !prompt_dangerous_tile( dest_loc ) ) {
9429 return true;
9430 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "RUNNING" &&
9431 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9433 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9434 enumerate_as_string( harmful_stuff ) );
9435 return true;
9436 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "CROUCHING" &&
9437 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9439 _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ),
9440 enumerate_as_string( harmful_stuff ) );
9441 return true;
9442 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "NEVER" &&
9443 !u.movement_mode_is( CMM_RUN ) ) {
9445 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9446 enumerate_as_string( harmful_stuff ) );
9447 return true;
9448 }
9449 }
9450 // Used to decide whether to print a 'moving is slow message
9451 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
9452
9453 int modifier = 0;
9454 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
9455 modifier = -m.furn( dest_loc ).obj().movecost;
9456 }
9457
9458 int multiplier = 1;
9459 if( u.is_on_ground() ) {
9460 multiplier *= 3;
9461 }
9462
9463 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
9464 via_ramp ) * multiplier;
9465 if( grabbed_move( dest_loc - u.pos() ) ) {
9466 return true;
9467 } else if( mcost == 0 ) {
9468 return false;
9469 }
9470 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
9471 const int previous_moves = u.moves;
9472 if( u.is_mounted() ) {
9473 auto crit = u.mounted_creature.get();
9474 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
9475 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
9476 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
9477 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
9478 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
9479 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
9480 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
9481 return false;
9482 }
9483 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
9484 const double encumb_moves = u.get_weight() / 4800.0_gram;
9485 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
9486 if( u.movement_mode_is( CMM_WALK ) ) {
9487 crit->use_mech_power( -2 );
9488 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9489 crit->use_mech_power( -1 );
9490 } else if( u.movement_mode_is( CMM_RUN ) ) {
9491 crit->use_mech_power( -3 );
9492 }
9493 } else {
9494 u.moves -= u.run_cost( mcost, diag );
9495 /**
9496 TODO:
9497 This should really use the mounted creatures stamina, if mounted.
9498 Monsters don't currently have stamina however.
9499 For the time being just don't burn players stamina when mounted.
9500 */
9501 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
9502 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
9503 u.burn_move_stamina( previous_moves - u.moves );
9504 } else {
9505 //Burn half as much stamina if vehicle has wheels, without changing move time
9506 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
9507 }
9508 }
9509 // Max out recoil & reset aim point
9512
9513 // Print a message if movement is slow
9514 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
9515 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
9516 m.has_flag_ter_or_furn( "FUNGUS",
9517 dest_loc ); //fungal furniture has no slowing effect on mycus characters
9518 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
9519 mcost_to > 4 || mcost_from > 4 ) &&
9520 !( u.has_trait( trait_M_IMMUNE ) && fungus );
9521 if( slowed && !u.is_mounted() ) {
9522 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
9523 if( mcost_to >= mcost_from ) {
9524 if( auto displayed_part = vp_there.part_displayed() ) {
9525 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9526 displayed_part->part().name() );
9527 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9528 } else {
9529 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9530 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9531 }
9532 } else {
9533 if( auto displayed_part = vp_here.part_displayed() ) {
9534 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9535 displayed_part->part().name() );
9536 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9537 } else {
9538 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9539 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9540 }
9541 }
9542 }
9543 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9544 ( !u.footwear_factor() ||
9545 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9546 // DX and IN are long suits for Cephalopods,
9547 // so this shouldn't cause too much hardship
9548 // Presumed that if it's swimmable, they're
9549 // swimming and won't stick
9550 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9551
9552 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9553 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9554 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9555 u.mod_fatigue( 1 );
9556 }
9557 }
9558 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9559 int volume = u.is_stealthy() ? 3 : 6;
9560 volume *= u.mutation_value( "noise_modifier" );
9561 if( volume > 0 ) {
9563 volume = 2;
9564 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9565 volume = 12;
9566 }
9567 if( u.movement_mode_is( CMM_RUN ) ) {
9568 volume *= 1.5;
9569 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9570 volume /= 2;
9571 }
9572 if( u.is_mounted() ) {
9573 auto mons = u.mounted_creature.get();
9574 switch( mons->get_size() ) {
9575 case MS_TINY:
9576 volume = 0; // No sound for the tinies
9577 break;
9578 case MS_SMALL:
9579 volume /= 3;
9580 break;
9581 case MS_MEDIUM:
9582 break;
9583 case MS_LARGE:
9584 volume *= 1.5;
9585 break;
9586 case MS_HUGE:
9587 volume *= 2;
9588 break;
9589 default:
9590 break;
9591 }
9592 if( mons->has_flag( MF_LOUDMOVES ) ) {
9593 volume += 6;
9594 }
9595 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9596 "none", "none" );
9597 } else {
9598 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9599 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9600 }
9602 }
9603
9604 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9605 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9606 "misc", "rattling" );
9607 }
9608 }
9609
9610 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9611 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9612 }
9613
9614 if( dest_loc != u.pos() ) {
9616 }
9617
9618 tripoint oldpos = u.pos();
9619 point submap_shift = place_player( dest_loc );
9620 point ms_shift = sm_to_ms_copy( submap_shift );
9621 oldpos = oldpos - ms_shift;
9622
9623 if( pulling ) {
9624 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9625 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9626 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9627 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9628 m.remove_field( shifted_furn_pos, fd_fire );
9629 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9630 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9631 }
9632
9633 if( u.is_hauling() ) {
9634 start_hauling( oldpos );
9635 }
9636
9638
9639 return true;
9640}
void burn_move_stamina(int moves)
Definition: character.cpp:7233
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3218
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3662
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:957
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6761
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:536
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:10246
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9249
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1833
m_size get_size() const override
Definition: monster.cpp:2668
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:691
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2146
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ wield() [1/2]

void game::wield ( )
private

Definition at line 9109 of file game.cpp.

9110{
9112
9113 if( loc ) {
9114 wield( loc );
9115 } else {
9116 add_msg( _( "Never mind." ) );
9117 }
9118}
item_location wield(avatar &you)
Item wielding/unwielding menu.

References _, add_msg(), u, wield(), and game_menus::inv::wield().

Referenced by handle_action(), inventory_item_menu(), and wield().

◆ wield() [2/2]

void game::wield ( item_location loc)
private

Definition at line 9021 of file game.cpp.

9022{
9023 if( u.is_armed() ) {
9024 const bool is_unwielding = u.is_wielding( *loc );
9025 const auto ret = u.can_unwield( *loc );
9026
9027 if( !ret.success() ) {
9028 add_msg( m_info, "%s", ret.c_str() );
9029 }
9030
9031 u.unwield();
9032
9033 if( is_unwielding ) {
9034 if( !u.martial_arts_data->selected_is_none() ) {
9035 u.martial_arts_data->martialart_use_message( u );
9036 }
9037 return;
9038 }
9039 }
9040
9041 const auto ret = u.can_wield( *loc );
9042 if( !ret.success() ) {
9043 add_msg( m_info, "%s", ret.c_str() );
9044 }
9045
9046 // Need to do this here because holster_actor::use() checks if/where the item is worn
9047 item &target = *loc.get_item();
9048 if( target.get_use( "holster" ) && !target.contents.empty() ) {
9049 //~ %1$s: weapon name, %2$s: holster name
9050 if( query_yn( pgettext( "holster", "Draw %1$s from %2$s?" ), target.get_contained().tname(),
9051 target.tname() ) ) {
9052 u.invoke_item( &target );
9053 return;
9054 }
9055 }
9056
9057 // Can't use loc.obtain() here because that would cause things to spill.
9058 item to_wield = *loc.get_item();
9059 item_location::type location_type = loc.where();
9060 tripoint pos = loc.position();
9061 int worn_index = INT_MIN;
9062 if( u.is_worn( *loc.get_item() ) ) {
9063 auto ret = u.can_takeoff( *loc.get_item() );
9064 if( !ret.success() ) {
9065 add_msg( m_info, "%s", ret.c_str() );
9066 return;
9067 }
9068 int item_pos = u.get_item_position( loc.get_item() );
9069 if( item_pos != INT_MIN ) {
9070 worn_index = Character::worn_position_to_index( item_pos );
9071 }
9072 }
9073 loc.remove_item();
9074 if( !u.wield( to_wield ) ) {
9075 switch( location_type ) {
9077 // this will not cause things to spill, as it is inside another item
9078 loc = loc.obtain( g->u );
9079 wield( loc );
9080 break;
9082 if( worn_index != INT_MIN ) {
9083 auto it = u.worn.begin();
9084 std::advance( it, worn_index );
9085 u.worn.insert( it, to_wield );
9086 } else {
9087 u.i_add( to_wield );
9088 }
9089 break;
9091 m.add_item( pos, to_wield );
9092 break;
9094 const cata::optional<vpart_reference> vp = m.veh_at( pos ).part_with_feature( "CARGO", false );
9095 // If we fail to return the item to the vehicle for some reason, add it to the map instead.
9096 if( !vp || !( vp->vehicle().add_item( vp->part_index(), to_wield ) ) ) {
9097 m.add_item( pos, to_wield );
9098 }
9099 break;
9100 }
9102 debugmsg( "Failed wield from invalid item location" );
9103 break;
9104 }
9105 return;
9106 }
9107}
std::list< item > worn
Definition: character.h:1573
static int worn_position_to_index(int position)
Definition: character.h:1137
item & i_add(item it, bool should_stack=true)
Definition: character.cpp:2319
bool wield(item &target) override
Removes currently wielded item (if any) and replaces it with the target item.
Definition: avatar.cpp:1210
type where() const
Returns the type of location where the item is found.
void remove_item()
Removes the selected item from the game.
tripoint position() const
Returns the position where the item is found.
const item & get_contained() const
Return a contained item (if any and only one).
Definition: item.cpp:6879
item & add_item(const tripoint &p, item new_item)
Place an item on the map, despite the parameter name, this is not necessarily a new item.
Definition: map.cpp:4314
ret_val< bool > can_wield(const item &it) const
Check player capable of wielding an item.
Definition: player.cpp:2491
bool unwield()
Definition: player.cpp:2530

References map::add_item(), add_msg(), player::can_takeoff(), Character::can_unwield(), player::can_wield(), item_location::character, item_location::container, item::contents, debugmsg, item_contents::empty(), g, item::get_contained(), item_location::get_item(), Character::get_item_position(), item::get_use(), Character::i_add(), item_location::invalid, avatar::invoke_item(), Character::is_armed(), Character::is_wielding(), Character::is_worn(), m, m_info, item_location::map, Character::martial_arts_data, item_location::obtain(), optional_vpart_position::part_with_feature(), pgettext(), item_location::position(), query_yn(), item_location::remove_item(), cata::hash64_detail::ret, item::tname(), u, player::unwield(), map::veh_at(), item_location::vehicle, item_location::where(), wield(), avatar::wield(), Character::worn, and Character::worn_position_to_index().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2746 of file game.cpp.

2747{
2748 win_screen();
2750 memorial().add(
2751 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2752 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2753 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2754 if( !u.is_dead_state() ) {
2757 }
2758}
void win_screen()
Definition: game.cpp:2760
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2760 of file game.cpp.

2761{
2762 // TODO: Move this wall somewhere
2764 std::string msg = _( "You managed to close the portal and end the invasion!" );
2765 msg += '\n';
2766 if( u.is_dead_state() ) {
2768 "Unfortunately, you had to sacrifice your life to achieve this." );
2769 msg += colorize( t, c_red ) + '\n';
2770 memorial().add(
2771 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2772 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2773 } else {
2774 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2775 msg += colorize( t, c_green ) + '\n';
2776 memorial().add(
2777 pgettext( "memorial_male", "Safely closed the portal." ),
2778 pgettext( "memorial_female", "Safely closed the portal." ) );
2779 }
2780 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2781 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2782 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2783 popup( msg );
2784}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 3149 of file game.cpp.

3150{
3151 const std::string &memorial_dir = PATH_INFO::memorialdir();
3152 const std::string &memorial_active_world_dir = memorial_dir +
3153 world_generator->active_world->world_name + "/";
3154
3155 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
3156 if( !assure_dir_exist( memorial_dir ) ) {
3157 debugmsg( "Could not make '%s' directory", memorial_dir );
3158 return;
3159 }
3160
3161 if( !assure_dir_exist( memorial_active_world_dir ) ) {
3162 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
3163 return;
3164 }
3165
3166 std::string path = memorial_active_world_dir + filename + ".txt";
3167
3168 write_to_file( path, [&]( std::ostream & fout ) {
3169 memorial().write( fout, sLastWords );
3170 }, _( "player memorial" ) );
3171}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6375 of file game.cpp.

6376{
6377 const tripoint stored_view_offset = u.view_offset;
6378
6380
6381 const int zone_ui_height = 12;
6382 const int zone_options_height = 7;
6383
6384 const int width = 45;
6385
6386 int offsetX = 0;
6387 int max_rows = 0;
6388
6389 catacurses::window w_zones;
6390 catacurses::window w_zones_border;
6391 catacurses::window w_zones_info;
6392 catacurses::window w_zones_info_border;
6393 catacurses::window w_zones_options;
6394
6395 bool show = true;
6396
6397 ui_adaptor ui;
6398 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6399 if( !show ) {
6400 ui.position( point_zero, point_zero );
6401 return;
6402 }
6403 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6404 TERMX - width : 0;
6405 const int w_zone_height = TERMY - zone_ui_height;
6406 max_rows = w_zone_height - 2;
6407 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6408 point( offsetX + 1, 1 ) );
6409 w_zones_border = catacurses::newwin( w_zone_height, width,
6410 point( offsetX, 0 ) );
6411 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6412 width - 2, point( offsetX + 1, w_zone_height ) );
6413 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6414 point( offsetX, w_zone_height ) );
6415 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6416 point( offsetX + 1, TERMY - zone_options_height ) );
6417
6418 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6419 } );
6420 ui.mark_resize();
6421
6422 std::string action;
6423 input_context ctxt( "ZONES_MANAGER" );
6424 ctxt.register_cardinal();
6425 ctxt.register_action( "CONFIRM" );
6426 ctxt.register_action( "QUIT" );
6427 ctxt.register_action( "ADD_ZONE" );
6428 ctxt.register_action( "REMOVE_ZONE" );
6429 ctxt.register_action( "MOVE_ZONE_UP" );
6430 ctxt.register_action( "MOVE_ZONE_DOWN" );
6431 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6432 ctxt.register_action( "ENABLE_ZONE" );
6433 ctxt.register_action( "DISABLE_ZONE" );
6434 ctxt.register_action( "SHOW_ALL_ZONES" );
6435 ctxt.register_action( "HELP_KEYBINDINGS" );
6436
6437 auto &mgr = zone_manager::get_manager();
6438 int start_index = 0;
6439 int active_index = 0;
6440 bool blink = false;
6441 bool stuff_changed = false;
6442 bool show_all_zones = false;
6443 int zone_cnt = 0;
6444
6445 // get zones on the same z-level, with distance between player and
6446 // zone center point <= 50 or all zones, if show_all_zones is true
6447 auto get_zones = [&]() {
6448 std::vector<zone_manager::ref_zone_data> zones;
6449 if( show_all_zones ) {
6450 zones = mgr.get_zones();
6451 } else {
6452 const tripoint &u_abs_pos = m.getabs( u.pos() );
6453 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6454 const tripoint &zone_abs_pos = ref.get().get_center_point();
6455 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6456 zones.emplace_back( ref );
6457 }
6458 }
6459 }
6460 zone_cnt = static_cast<int>( zones.size() );
6461 return zones;
6462 };
6463
6464 auto zones = get_zones();
6465
6466 auto zones_manager_options = [&]() {
6467 werase( w_zones_options );
6468
6469 if( zone_cnt > 0 ) {
6470 const auto &zone = zones[active_index].get();
6471
6472 if( zone.has_options() ) {
6473 const auto &descriptions = zone.get_options().get_descriptions();
6474
6475 // NOLINTNEXTLINE(cata-use-named-point-constants)
6476 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6477
6478 int y = 1;
6479 for( const auto &desc : descriptions ) {
6480 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6481 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6482 y++;
6483 }
6484 }
6485 }
6486
6487 wnoutrefresh( w_zones_options );
6488 };
6489
6490 cata::optional<tripoint> zone_start;
6491 cata::optional<tripoint> zone_end;
6492 bool zone_blink = false;
6493 bool zone_cursor = false;
6495 zone_start, zone_end, zone_blink, zone_cursor );
6496 add_draw_callback( zone_cb );
6497
6498 auto query_position =
6499 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6500 on_out_of_scope invalidate_current_ui( [&]()
6501 {
6502 ui.mark_resize();
6503 } );
6504 restore_on_out_of_scope<bool> show_prev( show );
6505 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6506 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6507 show = false;
6508 zone_start = cata::nullopt;
6509 zone_end = cata::nullopt;
6510 ui.mark_resize();
6511
6513 popup.on_top( true );
6514 popup.message( "%s", _( "Select first point." ) );
6515
6517
6518 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6519 false );
6520 if( first.position )
6521 {
6522 popup.message( "%s", _( "Select second point." ) );
6523
6524 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6525 true, true, false );
6526 if( second.position ) {
6527 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6528 second.position->x ),
6529 std::min( first.position->y, second.position->y ),
6530 std::min( first.position->z,
6531 second.position->z ) ) );
6532 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6533 second.position->x ),
6534 std::max( first.position->y, second.position->y ),
6535 std::max( first.position->z,
6536 second.position->z ) ) );
6537 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6538 }
6539 }
6540
6541 return cata::nullopt;
6542 };
6543
6544 ui.on_redraw( [&]( const ui_adaptor & ) {
6545 if( !show ) {
6546 return;
6547 }
6548 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6549 zones_manager_shortcuts( w_zones_info );
6550
6551 if( zone_cnt == 0 ) {
6552 werase( w_zones );
6553 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6554
6555 } else {
6556 werase( w_zones );
6557
6558 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6559
6560 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6561 wnoutrefresh( w_zones_border );
6562
6563 int iNum = 0;
6564
6565 tripoint player_absolute_pos = m.getabs( u.pos() );
6566
6567 //Display saved zones
6568 for( auto &i : zones ) {
6569 if( iNum >= start_index &&
6570 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6571 const auto &zone = i.get();
6572
6573 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6574
6575 if( iNum == active_index ) {
6576 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6577 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6578 }
6579
6580 //Draw Zone name
6581 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6582 trim_by_length( zone.get_name(), 15 ) );
6583
6584 //Draw Type name
6585 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6586 mgr.get_name_from_type( zone.get_type() ) );
6587
6588 tripoint center = zone.get_center_point();
6589
6590 //Draw direction + distance
6591 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6592 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6593 direction_name_short( direction_from( player_absolute_pos,
6594 center ) ) );
6595
6596 //Draw Vehicle Indicator
6597 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6598 zone.get_is_vehicle() ? "*" : "" );
6599 }
6600 iNum++;
6601 }
6602
6603 // Display zone options
6604 zones_manager_options();
6605 }
6606
6607 wnoutrefresh( w_zones );
6608 } );
6609
6610 zones_manager_open = true;
6611 do {
6612 if( action == "ADD_ZONE" ) {
6613 do { // not a loop, just for quick bailing out if canceled
6614 const auto maybe_id = mgr.query_type();
6615 if( !maybe_id.has_value() ) {
6616 break;
6617 }
6618
6619 const zone_type_id &id = maybe_id.value();
6620 auto options = zone_options::create( id );
6621
6622 if( !options->query_at_creation() ) {
6623 break;
6624 }
6625
6626 auto default_name = options->get_zone_name_suggestion();
6627 if( default_name.empty() ) {
6628 default_name = mgr.get_name_from_type( id );
6629 }
6630 const auto maybe_name = mgr.query_name( default_name );
6631 if( !maybe_name.has_value() ) {
6632 break;
6633 }
6634 const std::string &name = maybe_name.value();
6635
6636 const auto position = query_position();
6637 if( !position ) {
6638 break;
6639 }
6640
6641 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6642 position->second, options );
6643
6644 zones = get_zones();
6645 active_index = zone_cnt - 1;
6646
6647 stuff_changed = true;
6648 } while( false );
6649
6650 blink = false;
6651 } else if( action == "SHOW_ALL_ZONES" ) {
6652 show_all_zones = !show_all_zones;
6653 zones = get_zones();
6654 active_index = 0;
6655 } else if( zone_cnt > 0 ) {
6656 if( action == "UP" ) {
6657 active_index--;
6658 if( active_index < 0 ) {
6659 active_index = zone_cnt - 1;
6660 }
6661 blink = false;
6662 } else if( action == "DOWN" ) {
6663 active_index++;
6664 if( active_index >= zone_cnt ) {
6665 active_index = 0;
6666 }
6667 blink = false;
6668 } else if( action == "REMOVE_ZONE" ) {
6669 if( active_index < zone_cnt ) {
6670 mgr.remove( zones[active_index] );
6671 zones = get_zones();
6672 active_index--;
6673
6674 if( active_index < 0 ) {
6675 active_index = 0;
6676 }
6677 }
6678 blink = false;
6679 stuff_changed = true;
6680
6681 } else if( action == "CONFIRM" ) {
6682 auto &zone = zones[active_index].get();
6683
6684 uilist as_m;
6685 as_m.text = _( "What do you want to change:" );
6686 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6687 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6688 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6689 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6690 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6691 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6692 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6693 as_m.query();
6694
6695 switch( as_m.ret ) {
6696 case 1:
6697 if( zone.set_name() ) {
6698 stuff_changed = true;
6699 }
6700 break;
6701 case 2:
6702 if( zone.set_type() ) {
6703 stuff_changed = true;
6704 }
6705 break;
6706 case 3:
6707 if( zone.get_options().query() ) {
6708 stuff_changed = true;
6709 }
6710 break;
6711 case 4: {
6712 const auto pos = query_position();
6713 if( pos && ( pos->first != zone.get_start_point() ||
6714 pos->second != zone.get_end_point() ) ) {
6715 zone.set_position( *pos );
6716 stuff_changed = true;
6717 }
6718 break;
6719 }
6720 case 5: {
6721 on_out_of_scope invalidate_current_ui( [&]() {
6722 ui.mark_resize();
6723 } );
6724 restore_on_out_of_scope<bool> show_prev( show );
6725 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6726 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6727 show = false;
6728 zone_start = cata::nullopt;
6729 zone_end = cata::nullopt;
6730 ui.mark_resize();
6731 static_popup message_pop;
6732 message_pop.on_top( true );
6733 message_pop.message( "%s", _( "Moving zone." ) );
6734 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6735 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6736 // local position of the zone center, used to calculate the u.view_offset,
6737 // could center the screen to the position it represents
6738 auto view_center = m.getlocal( zone.get_center_point() );
6739 const look_around_result result_local = look_around( false, view_center,
6740 zone_local_start_point, false, false,
6741 false, true, zone_local_end_point );
6742 if( result_local.position ) {
6743 const auto new_start_point = m.getabs( *result_local.position );
6744 if( new_start_point == zone.get_start_point() ) {
6745 break; // Nothing changed, don't save
6746 }
6747
6748 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6749 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6750 stuff_changed = true;
6751 }
6752 }
6753 break;
6754 default:
6755 break;
6756 }
6757
6758 blink = false;
6759 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6760 if( active_index < zone_cnt - 1 ) {
6761 mgr.swap( zones[active_index], zones[active_index + 1] );
6762 zones = get_zones();
6763 active_index++;
6764 }
6765 blink = false;
6766 stuff_changed = true;
6767
6768 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6769 if( active_index > 0 ) {
6770 mgr.swap( zones[active_index], zones[active_index - 1] );
6771 zones = get_zones();
6772 active_index--;
6773 }
6774 blink = false;
6775 stuff_changed = true;
6776
6777 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6778 //show zone position on overmap;
6779 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6780 // TODO: fix point types
6781 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6782
6783 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6784 } else if( action == "ENABLE_ZONE" ) {
6785 zones[active_index].get().set_enabled( true );
6786
6787 stuff_changed = true;
6788
6789 } else if( action == "DISABLE_ZONE" ) {
6790 zones[active_index].get().set_enabled( false );
6791
6792 stuff_changed = true;
6793 }
6794 }
6795
6796 if( zone_cnt > 0 ) {
6797 blink = !blink;
6798 const auto &zone = zones[active_index].get();
6799 zone_start = m.getlocal( zone.get_start_point() );
6800 zone_end = m.getlocal( zone.get_end_point() );
6801 ctxt.set_timeout( BLINK_SPEED );
6802 } else {
6803 blink = false;
6804 zone_start = zone_end = cata::nullopt;
6805 ctxt.reset_timeout();
6806 }
6807
6808 // Actually accessed from the terrain overlay callback `zone_cb` in the
6809 // call to `ui_manager::redraw`.
6810 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6811 zone_blink = blink;
6813
6815
6816 //Wait for input
6817 action = ctxt.handle_input();
6818 } while( action != "QUIT" );
6819 zones_manager_open = false;
6820 ctxt.reset_timeout();
6821 zone_cb = nullptr;
6822
6823 if( stuff_changed ) {
6824 auto &zones = zone_manager::get_manager();
6825 if( query_yn( _( "Save changes?" ) ) ) {
6826 zones.save_zones();
6827 } else {
6828 zones.load_zones();
6829 }
6830
6831 zones.cache_data();
6832 }
6833
6834 u.view_offset = stored_view_offset;
6835}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:345
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:185
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6310
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6333
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7329 of file game.cpp.

7330{
7331#if defined(TILES)
7332 if( tileset_zoom == 64 ) {
7333 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7334 } else {
7336 }
7337 rescale_tileset( tileset_zoom );
7338#endif
7339}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7317 of file game.cpp.

7318{
7319#if defined(TILES)
7320 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7322 } else {
7323 tileset_zoom = 64;
7324 }
7325 rescale_tileset( tileset_zoom );
7326#endif
7327}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 100 of file avatar.cpp.

101{
102 return g->u;
103}

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12592 of file game.cpp.

12593{
12594 return *g->grid_tracker_ptr;
12595}

◆ get_map

map & get_map ( )
friend

Definition at line 142 of file map.cpp.

143{
144 return g->m;
145}

Referenced by check_art_charge_req(), extended_description(), find_empty_spot_nearby(), get_fire_fuel_string(), and print_terrain_info().

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 383 of file character.cpp.

384{
385 return g->u;
386}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 1003 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1066 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1083 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1097 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1047 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1048 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1060 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 967 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1058 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1045 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 1001 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1099 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 1007 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 1004 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1116 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1118 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1117 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1089 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1090 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1080 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1079 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 998 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 997 of file game.h.

◆ m

map& game::m

Definition at line 1011 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 995 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 1005 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1032 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1088 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1028 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1086 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1084 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1095 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1067 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1093 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1092 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1063 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1082 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1030 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 1013 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 999 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1111 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1078 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1062 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 1006 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 1002 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1034 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1108 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 1000 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 1014 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 1023 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1069 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 1012 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), favorite_ammo_or_select(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), inventory_item_menu(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), open_gate(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), reload(), reload_item(), reload_weapon(), reload_wielded(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), unload(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 996 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1073 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 1026 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1105 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1038 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1076 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1037 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1036 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1075 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1124 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1065 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 1008 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1101 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: